Interface ClientToServer

This is an exhaustive list of the messages that the client can send to the server.

This documentation is generated from the official typescript interface. To interpret it, you will every message organized as the name of the message followed by a function taking the message data parameters and returning what you can expect tor receive back.

For example, the authentication message documentation looks like this:

  authenticate: ((data: {
      bot_apikey?: string;
      bot_username?: string;
      client?: string;
      client_version?: string;
      device_id?: string;
      jwt: string;
      language?: string;
      language_version?: string;
      user_agent?: string;
  }) => undefined | {
      id: number;
      username: string;
  })

The command you will send is authenticate, the data you send will be an object with the following format:

 {
     bot_apikey?: string;
     bot_username?: string;
     client?: string;
     client_version?: string;
     device_id?: string;
     jwt: string;
     language?: string;
     language_version?: string;
     user_agent?: string;
 }

and you can expect to receive back either undefined or {id: number, username: string}

interface ClientToServer {
    authenticate: ((data) => undefined | {
        id: number;
        username: string;
    });
    automatch/cancel: ((data) => void);
    automatch/find_match: ((data) => void);
    automatch/list: ((data) => void);
    bot/config: ((config) => void);
    bot/status: ((data) => void);
    challenge/keepalive: ((data) => void);
    chat/join: ((data) => void);
    chat/part: ((data) => void);
    chat/pm: ((data) => undefined | {
        from: User;
        message: {
            i: string;
            m: string;
            t: number;
        };
        to: {
            id: number;
            username: string;
        };
    });
    chat/pm/close: ((data) => void);
    chat/pm/load: ((data) => void);
    chat/pm/superchat: ((data) => void);
    chat/remove: ((data) => void);
    chat/remove_all: ((data) => void);
    chat/send: ((data) => void);
    chat/topic: ((data) => void);
    game/annul: ((data) => void);
    game/cancel: ((data) => void);
    game/chat: ((data) => void);
    game/chat/remove: ((data) => void);
    game/clear_delayed_resign: ((data) => void);
    game/conditional_moves/set: ((data) => void);
    game/connect: ((data) => void);
    game/delayed_resign: ((data) => void);
    game/disconnect: ((data) => void);
    game/latency: ((data) => void);
    game/log: ((data) => {
        data: any;
        event: string;
        timestamp: string;
    }[]);
    game/move: ((data) => void);
    game/pause: ((data) => void);
    game/prevent_escaping: ((data) => void);
    game/prevent_stalling: ((data) => void);
    game/removed_stones/accept: ((data) => void);
    game/removed_stones/reject: ((data) => void);
    game/removed_stones/set: ((data) => void);
    game/resign: ((data) => void);
    game/resume: ((data) => void);
    game/timed_out: ((data) => void);
    game/undo/accept: ((data) => void);
    game/undo/cancel: ((data) => void);
    game/undo/request: ((data) => void);
    gamelist/count/subscribe: ((data) => void);
    gamelist/count/unsubscribe: ((data) => void);
    gamelist/query: ((data) => undefined | {
        by: string;
        from: number;
        limit: number;
        list: string;
        results: GameListEntry[];
        size: number;
        where: GameListWhere;
    });
    hostinfo: ((data) => {
        clients: number;
        ggs-version: string;
        hostname: string;
        uptime: number;
    });
    itc: ((data) => void);
    net/ping: ((data) => void);
    notification/delete: ((data) => void);
    remote_storage/remove: ((data) => {
        error?: string;
        retry?: boolean;
    } | {
        success: true;
    });
    remote_storage/set: ((data) => {
        error?: string;
        retry?: boolean;
    } | {
        success: true;
    });
    remote_storage/sync: ((data) => {
        error?: string;
        retry?: boolean;
    } | {
        success: true;
    });
    review/append: ((data) => void);
    review/chat: ((data) => void);
    review/chat/remove: ((data) => void);
    review/connect: ((data) => void);
    review/disconnect: ((data) => void);
    seek_graph/connect: ((data) => void);
    seek_graph/disconnect: ((data) => void);
    stats/online: ((data) => number);
    ui-pushes/subscribe: ((data) => void);
    ui-pushes/unsubscribe: ((data) => void);
    user/monitor: ((data) => void);
}

Hierarchy (view full)

ClientToServerBase
- ClientToServer

Index

Properties

authenticate automatch/cancel automatch/find_match automatch/list bot/config bot/status challenge/keepalive chat/join chat/part chat/pm chat/pm/close chat/pm/load chat/pm/superchat chat/remove chat/remove_all chat/send chat/topic game/annul game/cancel game/chat game/chat/remove game/clear_delayed_resign game/conditional_moves/set game/connect game/delayed_resign game/disconnect game/latency game/log game/move game/pause game/prevent_escaping game/prevent_stalling game/removed_stones/accept game/removed_stones/reject game/removed_stones/set game/resign game/resume game/timed_out game/undo/accept game/undo/cancel game/undo/request gamelist/count/subscribe gamelist/count/unsubscribe gamelist/query hostinfo itc net/ping notification/delete remote_storage/remove remote_storage/set remote_storage/sync review/append review/chat review/chat/remove review/connect review/disconnect seek_graph/connect seek_graph/disconnect stats/online ui-pushes/subscribe ui-pushes/unsubscribe user/monitor

Properties

authenticate

authenticate: ((data) => undefined | {
id: number;
username: string;
})

Authenticate with the server.

Prior to authentication, you should perform a GET request to /api/v1/ui/config to get the current configuration. Within the returned JSON you will find all of the necessary fields to authenticate.

Type declaration

- (data): undefined | {
  id: number;
  username: string;
  }
- Parameters
  - data: {
        bot_apikey?: string;
        bot_username?: string;
        client?: string;
        client_version?: string;
        device_id?: string;
        jwt: string;
        language?: string;
        language_version?: string;
        user_agent?: string;
    }
    - Optional bot_apikey?: string
      Bot API key, if applicable
    - Optional bot_username?: string
      Bot username connecting, if applicable
    - Optional client?: string
      Client name (your application name)
    - Optional client_version?: string
      Client version string.
    - Optional device_id?: string
      Client generated unique id for the device.
    - jwt: string
      The JSON Web Token (user_jwt field) from /api/v1/ui/config. If connecting as a guest, send ""
    - Optional language?: string
      ISO 639-1 language code used on this device.
    - Optional language_version?: string
      The version of the translation dictionary.
    - Optional user_agent?: string
      Browser user agent (or websocket library)
  Returns undefined | {
  id: number;
  username: string;
  }

automatch/cancel

automatch/cancel: ((data) => void)

Cancel a match request

Type declaration

- (data): void
- Parameters
  - data: {
    uuid: string;
    }
    - uuid: string
  Returns void

automatch/find_match

automatch/find_match: ((data) => void)

Request a match via the automatch system

Type declaration

- (data): void
- Parameters
  - data: AutomatchPreferences
  Returns void

automatch/list

automatch/list: ((data) => void)

Get active automatch entries for the current user

Type declaration

- (data): void
- Parameters
  - data: {}
  Returns void

bot/config

bot/config: ((config) => void)

Updates the config for the bot

Type declaration

- (config): void
- Parameters
  - config: any
  Returns void

bot/status

bot/status: ((data) => void)

Update the number of games that the bot is currently playing

Type declaration

- (data): void
- Parameters
  - data: {
        ongoing_blitz_count: number;
        ongoing_correspondence_count: number;
        ongoing_live_count: number;
    }
    - ongoing_blitz_count: number
    - ongoing_correspondence_count: number
    - ongoing_live_count: number
  Returns void

challenge/keepalive

challenge/keepalive: ((data) => void)

Message to let the server know the client is still interested in the specified blitz or live challenge. These should be sent about once a second to prevent the server from canceling the challenge.

Type declaration

- (data): void
- Parameters
  - data: {
    challenge_id: number;
    game_id: number;
    }
    - challenge_id: number
    - game_id: number
  Returns void

chat/join

chat/join: ((data) => void)

Join a chat channel

Type declaration

- (data): void
- Parameters
  - data: {
    channel: string;
    }
    - channel: string
      Channel to join
  Returns void

chat/part

chat/part: ((data) => void)

Leave a channel

Type declaration

- (data): void
- Parameters
  - data: {
    channel: string;
    }
    - channel: string
      Channel to leave
  Returns void

chat/pm

chat/pm: ((data) => undefined | {
    from: User;
    message: {
        i: string;
        m: string;
        t: number;
    };
    to: {
        id: number;
        username: string;
    };
})

Send a private message to another user

Type declaration

- (data): undefined | {
      from: User;
      message: {
          i: string;
          m: string;
          t: number;
      };
      to: {
          id: number;
          username: string;
      };
  }
- Parameters
  - data: {
        as_system?: true;
        message: string;
        player_id: number;
        uid: string;
        username: string;
    }
    - Optional as_system?: true
      Moderator option to send the chat from the system not from their personal PM
    - message: string
      Message text
    - player_id: number
      Player ID of the recipient
    - uid: string
      UUID for the message
    - username: string
      Username of the recipient
  Returns undefined | {
      from: User;
      message: {
          i: string;
          m: string;
          t: number;
      };
      to: {
          id: number;
          username: string;
      };
  }

chat/pm/close

chat/pm/close: ((data) => void)

Closes the current user's private message session with the given player id

Type declaration

- (data): void
- Parameters
  - data: {
    player_id: number;
    }
    - player_id: number
  Returns void

chat/pm/load

chat/pm/load: ((data) => void)

Loads the current user's private message session history with the given player id

Type declaration

- (data): void
- Parameters
  - data: {
    player_id: number;
    }
    - player_id: number
  Returns void

chat/pm/superchat

chat/pm/superchat: ((data) => void)

Begins a "super chat" session with the given player id, which creates an unclosable dialog if enable is true, and makes the dialog closable again if enable is false. This is only available to moderators.

Type declaration

- (data): void
- Parameters
  - data: {
        enable: boolean;
        player_id: number;
        username: string;
    }
    - enable: boolean
      Set to true if you want the modal to be unclosable, false if you want the modal to be closable again
    - player_id: number
    - username: string
      Username of the recipient
  Returns void

chat/remove

chat/remove: ((data) => void)

Moderator only command to remove a single chat message

Type declaration

- (data): void
- Parameters
  - data: {
    uuid: string;
    }
    - uuid: string
  Returns void

chat/remove_all

chat/remove_all: ((data) => void)

Moderator only command to remove all chat messages for a given player

Type declaration

- (data): void
- Parameters
  - data: {
    player_id: number;
    }
    - player_id: number
      Player id to remove all messages for
  Returns void

chat/send

chat/send: ((data) => void)

Sends a chat message to the given channel

Type declaration

- (data): void
- Parameters
  - data: {
        channel: string;
        message: string;
        uuid: string;
    }
    - channel: string
      Channel to send the message to
    - message: string
      Message text
    - uuid: string
      ID for the message
  Returns void

chat/topic

chat/topic: ((data) => void)

Sets a channel topic

Type declaration

- (data): void
- Parameters
  - data: {
    channel: string;
    topic: string;
    }
    - channel: string
    - topic: string
  Returns void

game/annul

game/annul: ((data) => void)

In Japanese rules, if the game is found to be repeating, the players may opt to annul the entire game and start over.

This is largely undesired in an online setting and support for this will probably be removed in the future, dont' bother implementing this.

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/cancel

game/cancel: ((data) => void)

Cancels a game. This is effectively the same as resign, except the game will not be ranked. This is only allowed within the first few moves of the game. (See GobanEngine.gameCanBeCancelled for cancellation )

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/chat

game/chat: ((data) => void)

Sends a chat message to a game

Type declaration

- (data): void
- Parameters
  - data: {
        body: string | GameChatTranslatedMessage | GameChatAnalysisMessage | GameChatReviewMessage;
        game_id: number;
        move_number: number;
        type: "main" | "malkovich" | "moderator" | "hidden" | "personal";
    }
    - body: string | GameChatTranslatedMessage | GameChatAnalysisMessage | GameChatReviewMessage
      The chat message
    - game_id: number
      The game id
    - move_number: number
      The move number currently being viewed
    - type: "main" | "malkovich" | "moderator" | "hidden" | "personal"
      The type of chat message being sent
  Returns void

game/chat/remove

game/chat/remove: ((data) => void)

Moderator only command to remove a single chat message from a game

Type declaration

- (data): void
- Parameters
  - data: {
        channel: string;
        chat_id: string;
        game_id: number;
    }
    - channel: string
    - chat_id: string
    - game_id: number
  Returns void

game/clear_delayed_resign

game/clear_delayed_resign: ((data) => void)

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/conditional_moves/set

game/conditional_moves/set: ((data) => void)

Sets conditional moves to be made on behalf of the player in response to a move by the opponent.

Type declaration

- (data): void
- Parameters
  - 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 conditional moves are rooted in
  Returns void

game/connect

game/connect: ((data) => void)

Connect to a game. Once connected, the client will receive game updates relevant to the game.

Type declaration

- (data): void
- Parameters
  - data: {
    chat?: boolean;
    game_id: number;
    }
    - Optional chat?: boolean
      If true, the client will receive the game chat log and new chat events
    - game_id: number
      The game id to connect to
  Returns void

game/delayed_resign

game/delayed_resign: ((data) => void)

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/disconnect

game/disconnect: ((data) => void)

Disconnect from a game. This will stop game updates for a particular game.

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
  Returns void

game/latency

game/latency: ((data) => void)

Update your latency information for a particular game. This is used for clock synchronization. It is not strictly required, however strongly suggested for live games.

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    latency: number;
    }
    - game_id: number
      The game id
    - latency: number
      Network latency, measured in milliseconds. See net/ping to measure this.
  Returns void

game/log

game/log: ((data) => {
    data: any;
    event: string;
    timestamp: string;
}[])

Returns an event log for the given game. This is primarily for moderation purposes, although the endpoint is generally available to all users.

Type declaration

- (data): {
      data: any;
      event: string;
      timestamp: string;
  }[]
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
  Returns {
      data: any;
      event: string;
      timestamp: string;
  }[]

game/move

game/move: ((data) => void)

Submit a move for a game

Type declaration

- (data): void
- Parameters
  - data: {
        blur?: number;
        clock?: JGOFPlayerClock;
        game_id: number;
        move: string;
    }
    - Optional blur?: number
      Maximum number of milliseconds the client was out of focus between the last move and this move
    - Optional clock?: JGOFPlayerClock
      Clock according to the client. If this is within the margin of error of the server's clock, the server will accept the new clock value. If not provided, the server clock will be used.
    - game_id: number
      The game id
    - move: string
      The move number to play at
  Returns void

game/pause

game/pause: ((data) => void)

Pauses the game clocks

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/prevent_escaping

game/prevent_escaping: ((data) => void)

Request the server end a game that someone has left without resigning from

Type declaration

- (data): void
- Parameters
  - data: {
        annul: boolean;
        game_id: number;
        winner: "black" | "white";
    }
    - annul: boolean
      Request that the game be annulled or not
    - game_id: number
      The game id
    - winner: "black" | "white"
      The proposed winner
  Returns void

game/prevent_stalling

game/prevent_stalling: ((data) => void)

Request the server end a game that is being stalled by one of the players. This will only work if the server agrees in the outcome.

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    winner: "black" | "white";
    }
    - game_id: number
      The game id
    - winner: "black" | "white"
      The proposed winner
  Returns void

game/removed_stones/accept

game/removed_stones/accept: ((data) => void)

Accepts the stones as removed. Once both players have accepted the same stones, the stone removal phase will conclude and the game will finish.

Type declaration

- (data): void
- Parameters
  - data: {
        game_id: number;
        stones: string;
        strict_seki_mode: boolean;
    }
    - game_id: number
      The game id
    - stones: string
      All of the stones that are accepted as removed, and all intersections marked as dame
    - strict_seki_mode: boolean
      Japanese rules technically have some special scoring rules about whether territory in seki should be counted or not. This is supported by the backend but clients should always set this to false in this era of the game, the official client no longer displays this as an option to the user as it was very largely unused and was a large source of confusion.
  Returns void

game/removed_stones/reject

game/removed_stones/reject: ((data) => void)

Rejects the removed stones and resumes the game from the stone removal phase

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/removed_stones/set

game/removed_stones/set: ((data) => void)

Sets removed stones in the stone removal phase.

Type declaration

- (data): void
- Parameters
  - data: {
        game_id: number;
        needs_sealing?: JGOFSealingIntersection[];
        removed: boolean;
        stones: string | JGOFMove[];
        strict_seki_mode?: boolean;
    }
    - game_id: number
      The game id
    - Optional needs_sealing?: JGOFSealingIntersection[]
      List of intersections that need to be sealed before the game can be correctly scored. Note, if this is undefined, the value will not be changed on the server side. To specify there are no more intersections that need to be cleared, set it to [] specifically.
    - removed: boolean
      True if the stones should be marked as removed (or intersections marked as dame if there is no stone there), false if they should be marked as not removed / open area.
    - stones: string | JGOFMove[]
      List of intersections that are to be removed.
    - Optional strict_seki_mode?: boolean
      Japanese rules technically have some special scoring rules about whether territory in seki should be counted or not. This is supported by the backend but the official client no longer displays this as an option to the user as it was very largely unused and was a large source of confusion. This field is deprecated and will likely be removed in the future.
  Returns void

game/resign

game/resign: ((data) => void)

Resigns from the game

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/resume

game/resume: ((data) => void)

Resumes the game clocks

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/timed_out

game/timed_out: ((data) => void)

Inform the server that the client believes it's clock has timed out and the game should be ended in a timeout. This is not strictly necessary to implement as the server will also timeout games, however there is a grace period to account for network latency, so well behaved clients can (and should) send this message to be very exact with timeouts.

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    }
    - game_id: number
      The game id
  Returns void

game/undo/accept

game/undo/accept: ((data) => void)

Accepts an undo

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    move_number: number;
    }
    - game_id: number
      The game id
    - move_number: number
      The current move number
  Returns void

game/undo/cancel

game/undo/cancel: ((data) => void)

Cancels an undo request

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    move_number: number;
    }
    - game_id: number
      The game id
    - move_number: number
      The current move number
  Returns void

game/undo/request

game/undo/request: ((data) => void)

Requests an undo

Type declaration

- (data): void
- Parameters
  - data: {
    game_id: number;
    move_number: number;
    }
    - game_id: number
      The game id
    - move_number: number
      The current move number
  Returns void

gamelist/count/subscribe

gamelist/count/subscribe: ((data) => void)

Connects to the game list count. Once connected you'll start receiving gamelist-count or gamelist-count-${channel} messages.

Type declaration

- (data): void
- Parameters
  - data: {
    channel?: string;
    }
    - Optional channel?: string
      The group or tournament channel to subscribe to. If no channel is provided, the global server counts will be sent
  Returns void

gamelist/count/unsubscribe

gamelist/count/unsubscribe: ((data) => void)

Disconnects from the game list count

Type declaration

- (data): void
- Parameters
  - data: {
    channel?: string;
    }
    - Optional channel?: string
      The group or tournament channel to unsubscribe from. If no channel is provided, the global server counts will be unsubscribed from
  Returns void

gamelist/query

gamelist/query: ((data) => undefined | {
    by: string;
    from: number;
    limit: number;
    list: string;
    results: GameListEntry[];
    size: number;
    where: GameListWhere;
})

Queries the server for a list of games

Type declaration

- (data): undefined | {
      by: string;
      from: number;
      limit: number;
      list: string;
      results: GameListEntry[];
      size: number;
      where: GameListWhere;
  }
- Parameters
  - data: {
        channel?: string;
        from: number;
        limit: number;
        list: "live" | "corr" | "kidsgo";
        sort_by: "rank";
        where: GameListWhere;
    }
    - Optional channel?: string
      The group or tournament channel to query
    - from: number
      The number of games to skip before returning results
    - limit: number
      Number of games to return, between 1 and 300
    - list: "live" | "corr" | "kidsgo"
    - sort_by: "rank"
    - where: GameListWhere
      Filtering options
  Returns undefined | {
      by: string;
      from: number;
      limit: number;
      list: string;
      results: GameListEntry[];
      size: number;
      where: GameListWhere;
  }

hostinfo

hostinfo: ((data) => {
    clients: number;
    ggs-version: string;
    hostname: string;
    uptime: number;
})

Retrieve host information for the termination server you are connected to

Type declaration

- (data): {
      clients: number;
      ggs-version: string;
      hostname: string;
      uptime: number;
  }
- Parameters
  - data: {}
  Returns {
      clients: number;
      ggs-version: string;
      hostname: string;
      uptime: number;
  }
  - clients: number
  - ggs-version: string
  - hostname: string
  - uptime: number

itc

itc: ((data) => void)

Sends an "Inter Tab Communication" message to all other connected clients for the current user. This includes other devices, so the "Tab" part is a bit of a misnomer.

Type declaration

- (data): void
- Parameters
  - data: {
    data: any;
    event: string;
    }
    - data: any
      User defined data
    - event: string
      User defined event string
  Returns void

net/ping

net/ping: ((data) => void)

Sends a ping to the server. This message should be sent regularly. The default interval is 10 seconds. This keeps the connection alive and allows a client to measure clock drift and latency, both of which are vital to adjusting the client's game clock displays.

Type declaration

- (data): void
- Parameters
  - data: {
        client: number;
        drift: number;
        latency: number;
    }
    - client: number
      Client timestamp - milliseconds since epoch
    - drift: number
      Last clock drift measurement, or 0
    - latency: number
      Last latency measurement, or 0
  Returns void

notification/delete

notification/delete: ((data) => void)

Deletes a notification

Type declaration

- (data): void
- Parameters
  - data: {
    notification_id: string;
    }
    - notification_id: string
  Returns void

remote_storage/remove

remote_storage/remove: ((data) => {
    error?: string;
    retry?: boolean;
} | {
    success: true;
})

Remove the given key from remote storage system for this user

For more details on the remote storage replication system see: https://github.com/online-go/online-go.com/blob/devel/src/lib/data.ts

Type declaration

- (data): {
      error?: string;
      retry?: boolean;
  } | {
      success: true;
  }
- Parameters
  - data: {
    key: string;
    replication: RemoteStorageReplication;
    }
    - key: string
    - replication: RemoteStorageReplication
  Returns {
      error?: string;
      retry?: boolean;
  } | {
      success: true;
  }

remote_storage/set

remote_storage/set: ((data) => {
    error?: string;
    retry?: boolean;
} | {
    success: true;
})

Set the given key in the remote storage system for this user

For more details on the remote storage replication system see: https://github.com/online-go/online-go.com/blob/devel/src/lib/data.ts

Type declaration

- (data): {
      error?: string;
      retry?: boolean;
  } | {
      success: true;
  }
- Parameters
  - data: {
        key: string;
        replication: RemoteStorageReplication;
        value: any;
    }
    - key: string
    - replication: RemoteStorageReplication
    - value: any
  Returns {
      error?: string;
      retry?: boolean;
  } | {
      success: true;
  }

remote_storage/sync

remote_storage/sync: ((data) => {
    error?: string;
    retry?: boolean;
} | {
    success: true;
})

Requests all updated key/value pairs for this user since the provided timestamp (as as ISO 8601 string).

For more details on the remote storage replication system see: https://github.com/online-go/online-go.com/blob/devel/src/lib/data.ts

Type declaration

- (data): {
      error?: string;
      retry?: boolean;
  } | {
      success: true;
  }
- Parameters
  - data: {
    since: string;
    }
    - since: string
      ISO 8601 timestamp. Updates made after this timestamp will be sent to the client.
  Returns {
      error?: string;
      retry?: boolean;
  } | {
      success: true;
  }

review/append

review/append: ((data) => void)

Append a review action to the review log.

Type declaration

- (data): void
- Parameters
  - data: ReviewMessage
  Returns void

review/chat

review/chat: ((data) => void)

Sends a chat message to a review

Type declaration

- (data): void
- Parameters
  - data: {
        body: string;
        from: number;
        moves: string;
        review_id: number;
    }
    - body: string
      The chat message
    - from: number
      The root of the branch the user is viewing
    - moves: string
      The analysis branch the user is viewing
    - review_id: number
      The review id
  Returns void

review/chat/remove

review/chat/remove: ((data) => void)

Moderator only command to remove a single chat message from a game

Type declaration

- (data): void
- Parameters
  - data: {
        channel: string;
        chat_id: string;
        review_id: number;
    }
    - channel: string
    - chat_id: string
    - review_id: number
  Returns void

review/connect

review/connect: ((data) => void)

Connects to a review

Type declaration

- (data): void
- Parameters
  - data: {
    review_id: number;
    }
    - review_id: number
      The review id
  Returns void

review/disconnect

review/disconnect: ((data) => void)

Disconnects from a review

Type declaration

- (data): void
- Parameters
  - data: {
    review_id: number;
    }
    - review_id: number
      The review id
  Returns void

seek_graph/connect

seek_graph/connect: ((data) => void)

Subscribes to the seek graph events. The channel is required to be "global" for now and the foreseeable future.

Type declaration

- (data): void
- Parameters
  - data: {
    channel: "global";
    }
    - channel: "global"
  Returns void

seek_graph/disconnect

seek_graph/disconnect: ((data) => void)

Un-Subscribes to the seek graph events. The channel is required to be "global" for now and the foreseeable future.

Type declaration

- (data): void
- Parameters
  - data: {
    channel: "global";
    }
    - channel: "global"
  Returns void

stats/online

stats/online: ((data) => number)

Request the number of unique authenticated players online within the given interval

Type declaration

- (data): number
- Parameters
  - data: {
    interval: number;
    }
    - interval: number
      Interval in seconds
  Returns number

ui-pushes/subscribe

ui-pushes/subscribe: ((data) => void)

Subscribes to UI related push event messages sent to a particular channel

Type declaration

- (data): void
- Parameters
  - data: {
    channel: string;
    }
    - channel: string
  Returns void

ui-pushes/unsubscribe

ui-pushes/unsubscribe: ((data) => void)

Un-Subscribes to UI related push event messages sent to a particular channel

Type declaration

- (data): void
- Parameters
  - data: {
    channel: string;
    }
    - channel: string
  Returns void

user/monitor

user/monitor: ((data) => void)

Subscribes to online status updates for the given player ids

Type declaration

- (data): void
- Parameters
  - data: {
    user_ids: number[];
    }
    - user_ids: number[]
  Returns void

Interface ClientToServer

Hierarchy (view full)

Index

Properties

Properties

authenticate

Type declaration

Parameters

Optional bot_apikey?: string

Optional bot_username?: string

Optional client?: string

Optional client_version?: string

Optional device_id?: string

jwt: string

Optional language?: string

Optional language_version?: string

Optional user_agent?: string

Returns undefined | { id: number; username: string; }

automatch/cancel

Type declaration

Parameters

uuid: string

Returns void

automatch/find_match

Type declaration

Parameters

Returns void

automatch/list

Type declaration

Parameters

Returns void

bot/config

Type declaration

Parameters

Returns void

bot/status

Type declaration

Parameters

ongoing_blitz_count: number

ongoing_correspondence_count: number

ongoing_live_count: number

Returns void

challenge/keepalive

Type declaration

Parameters

challenge_id: number

game_id: number

Returns void

chat/join

Type declaration

Parameters

channel: string

Returns void

chat/part

Type declaration

Parameters

channel: string

Returns void

chat/pm

Type declaration

Parameters

Optional as_system?: true

message: string

player_id: number

uid: string

username: string

Returns undefined | { from: User; message: { i: string; m: string; t: number; }; to: { id: number; username: string; }; }

chat/pm/close

Type declaration

Parameters

player_id: number

Returns void

chat/pm/load

Type declaration

Parameters

player_id: number

Returns void

chat/pm/superchat

Type declaration

Parameters

`Optional` bot_apikey?: string

`Optional` bot_username?: string

`Optional` client?: string

`Optional` client_version?: string

`Optional` device_id?: string

`Optional` language?: string

`Optional` language_version?: string

`Optional` user_agent?: string

Returns undefined | {
id: number;
username: string;
}

`Optional` as_system?: true

Returns undefined | {
from: User;
message: {
i: string;
m: string;
t: number;
};
to: {
id: number;
username: string;
};
}

`Optional` chat?: boolean