Interface ServerToClient

data: string | {
    errcode: string;
}

data: {
    [id: number]: User;
}

• [id: number]: User

data: GameListEntry

data: {
    uuid: string;
}

• uuid: string

data: AutomatchPreferences

data: {
    game_id: number;
    uuid: string;
}

• game_id: number

• uuid: string

data: {
    channel: string;
    users: User[];
}

• channel: string

  The channel

• users: User[]

  List of users that joined

data: {
    channel: string;
    country?: string;
    id: number;
    message: {
        i?: string;
        m: string;
        t: number;
    };
    professional: boolean;
    ranking: number;
    system?: true;
    system_message_type?: "flood";
    ui_class: string;
    username: string;
}

• channel: string

  The channel

• Optional country?: string

  Country the user is from

• id: number

  User id of the sender

• message: {
      i?: string;
      m: string;
      t: number;
  }

  The message received

  • Optional i?: string

    Message id. This is always set for non system mesages.

  • m: string

    Message text

  • t: number

    Timestamp of the message

• professional: boolean

  True if the user is a professional

• ranking: number

  Ranking of the sender

• Optional system?: true

  Whether it's a system message or not

• Optional system_message_type?: "flood"

• ui_class: string

  UI class of the sender

• username: string

  Username of the sender

data: {
    channel: string;
    uuid: string;
}

• channel: string

  The channel

• uuid: string

  Message id. Note, despite the name, I don't think this is always a uuid in uuid format, just treat it as a string.

data: {
    channel: string;
    user: User;
}

• channel: string

  The channel

• user: User

  User that left

data: {
    channel: string;
    timestamp: number;
    topic: string;
}

• channel: string

  The channel

• timestamp: number

  Tiemstamp (ms) of the topic change

• topic: string

  The new topic

data: {
    channel: string;
    old_player_id: number;
    user: User;
}

• channel: string

  The channel

• old_player_id: number

  Player id entry that was update. This might change in the case of a guest logging in, in this case this will switch from being a nevative (guest) id, to some positive id. It is not expected that a non guest id should change using this system.

• user: User

  New user details

data: {
    expiration: number;
    game_id: number;
    player_id: number;
}

• expiration: number

  Whent he auto resign will happen

• game_id: number

  The game id

• player_id: number

  The player id

data: {
    channel: "main" | "malkovich" | "hidden" | "personal" | "spectator" | "shadowban";
    line: GameChatLine;
}

• channel: "main" | "malkovich" | "hidden" | "personal" | "spectator" | "shadowban"

• line: GameChatLine

data: {
    chat_ids: string[];
    game_id: number;
}

• chat_ids: string[]

  The chat ids

• game_id: number

  The game id

data: {
    game_id: number;
    player_id: number;
}

• game_id: number

  The game id

• player_id: number

  The player id

data: GameClock

data: {
    conditional_moves: ConditionalMoveResponse;
    game_id: number;
    move_number: number;
}

• conditional_moves: ConditionalMoveResponse

  The conditional moves. The top level should be an array that looks like [null, { ... }] where the second element contains the responses to the opponent's move.

• game_id: number

  The game id

• move_number: number

  The move number from which the condtional moves are rooted in

data: string

data: GoEngineConfig

data: {
    game_id: number;
    latency: number;
    player_id: number;
}

• game_id: number

  The game id

• latency: number

  The latency in milliseconds

• player_id: number

  The player id

data: "play" | "stone removal" | "finished"

data: {
    all_removed: string;
    removed: boolean;
    stones: string;
} | {
    strict_seki_mode: boolean;
}

data: {
    end_time: number;
    outcome: string;
    phase: "finished";
    player_id: number;
    players: {
        black: User | {
            accepted_stones: string;
            accepted_strict_seki_mode: boolean;
        };
        white: User | {
            accepted_stones: string;
            accepted_strict_seki_mode: boolean;
        };
    };
    score: Score;
    stones: string;
    strict_seki_mode: boolean;
    winner: number;
}

• end_time: number

  Timestamp in ms

• outcome: string

  Outcome of the game

• phase: "finished"

  Game phase (finished

• player_id: number

• players: {
      black: User | {
          accepted_stones: string;
          accepted_strict_seki_mode: boolean;
      };
      white: User | {
          accepted_stones: string;
          accepted_strict_seki_mode: boolean;
      };
  }

  Current players and their accepted stone statuses

  • black: User | {
        accepted_stones: string;
        accepted_strict_seki_mode: boolean;
    }

    Active black player id

  • white: User | {
        accepted_stones: string;
        accepted_strict_seki_mode: boolean;
    }

• score: Score

  Score

• stones: string

• strict_seki_mode: boolean

  True if Japanese strict seki mode was true. This will probably always be false and may be removed in the future.

• winner: number

  Player id of the winner

data: {
    game_id: number;
    gamestart_beep?: boolean;
    message: string;
    player_to_move: number;
}

• game_id: number

  The game id

• Optional gamestart_beep?: boolean

  If a gamestart sound should be played

• message: string

  A message to display as a notification, this seems to always be "Game has begun" for the time being.

• player_to_move: number

  The current player to move

data: number

data: number

data: number

data: {
    correspondence: number;
    live: number;
}

• correspondence: number

  Number of correspondence games

• live: number

  Number of live games

data: {
    correspondence: number;
    live: number;
}

• correspondence: number

  Number of correspondence games

• live: number

  Number of live games

data: {
    clients: number;
    hostname: string;
    uptime: number;
}

• clients: number

  Number of clients connected, if available

• hostname: string

  The hostname of the server

• uptime: number

  Number of seconds the server has been running

data: {
    cleared_by_user?: boolean;
    created: string;
    id: number;
    moderator?: User;
    moderator_note: string;
    report_type: string;
    reported_conversation?: string;
    reported_game?: number;
    reported_review?: number;
    reported_user?: User;
    reporter_note: string;
    reporter_note_translation: {
        source_language: string;
        source_text: string;
        target_language: string;
        target_text: string;
    };
    reporting_user?: User;
    source: string;
    state: "pending" | "claimed" | "resolved";
    system_note: string;
    updated: string;
    url: string;
    was_helpful: boolean;
}

• Optional cleared_by_user?: boolean

• created: string

• id: number

• Optional moderator?: User

• moderator_note: string

• report_type: string

• Optional reported_conversation?: string

• Optional reported_game?: number

• Optional reported_review?: number

• Optional reported_user?: User

• reporter_note: string

• reporter_note_translation: {
      source_language: string;
      source_text: string;
      target_language: string;
      target_text: string;
  }

  • source_language: string

  • source_text: string

  • target_language: string

  • target_text: string

• Optional reporting_user?: User

• source: string

• state: "pending" | "claimed" | "resolved"

• system_note: string

• updated: string

• url: string

• was_helpful: boolean

data: {
    data: any;
    event: string;
}

• data: any

  User defined data

• event: string

  User defined event string

data: {
    client: number;
    server: number;
}

• client: number

  Client timestamp that was sent

• server: number

  Server timestamp when it was received

data: {
    type: string;
    [key: string]: any;
}

• [key: string]: any

• type: string

  The notification type

data: {
    from: User;
    message: {
        i: string;
        m: string;
        t: number;
    };
    superchat_enabled?: boolean;
    to: User;
}

• from: User

  Who sent the message

• message: {
      i: string;
      m: string;
      t: number;
  }

  The message received

  • i: string

    Message id.

  • m: string

    Message text

  • t: number

    Timestamp of the message

• Optional superchat_enabled?: boolean

  If true, the private message should be forced to be in focus, this is when a moderator needs to talk with a player and ignoring the moderator is not suitable thing to do.

• to: User

  Your user id

data: {
    enable: boolean;
    moderator_id: number;
    moderator_username: string;
    player_id: number;
    player_username: string;
}

• enable: boolean

  Whether the superchat is enabled or not. When true, the client should make an undismissable chat window, when false the window can be dismissed.

• moderator_id: number

  The moderator id contacting the player

• moderator_username: string

  The moderator username contacting the player

• player_id: number

  Your id

• player_username: string

  Your username

data: {
    key: string;
    modified: string;
    replication: RemoteStorageReplication;
    value: any;
}

• key: string

  Key for the k/v pair

• modified: string

  Timestamp of the update

• replication: RemoteStorageReplication

  Replication mode

• value: any

  Value of of the k/v pair

data: ReviewMessage[]

data: ReviewMessage

data: {
    game_id: number;
    shared_ip_with_player: boolean;
}

• game_id: number

  The game ID

• shared_ip_with_player: boolean

  True if the client shares an IP with one of the players of the game

data: {
    challenge_id: number;
    delete: true;
} | {
    black: User;
    challenge_id: number;
    creator: number;
    game_id: number;
    game_started?: true;
    rengo?: true;
    rengo_auto_start?: boolean;
    rengo_black_team?: number[];
    rengo_casual_mode?: boolean;
    rengo_white_team?: number[];
    time_control: string;
    time_control_parameters: JGOFTimeControl;
    white: User;
} | {
    challenge_id: number;
    challenger_color: "black" | "white" | "automatic";
    disable_analysis: boolean;
    game_id: number;
    handicap: null | number;
    height: number;
    invite_only: boolean;
    komi: null | number;
    max_rank: number;
    min_rank: number;
    name: string;
    professional: boolean;
    ranked: boolean;
    ranking: number;
    rengo: boolean;
    rengo_auto_start: boolean;
    rengo_black_team: number[];
    rengo_casual_mode: boolean;
    rengo_nominees: number[];
    rengo_participants: number[];
    rengo_white_team: number[];
    rules: string;
    time_control: string;
    time_control_parameters: JGOFTimeControl;
    time_per_move: number;
    user_id: number;
    username: string;
    uuid: string;
    width: number;
}

data: {
    data: string;
    event: string;
}

• data: string

  UI Push data

• event: string

  UI Push event

data: {
    [player_id: number]: boolean;
}

• [player_id: number]: boolean