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)

Properties

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: ((data) => void)

Cancel a match request

Type declaration

    • (data): void
    • Parameters

      • data: {
            uuid: string;
        }
        • uuid: string

      Returns void

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

Request a match via the automatch system

Type declaration

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

Get active automatch entries for the current user

Type declaration

    • (data): void
    • Parameters

      • data: {}

        Returns void

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

    Updates the config for the bot

    Type declaration

      • (config): void
      • Parameters

        • config: any

        Returns void

    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: ((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: ((data) => void)

    Join a chat channel

    Type declaration

      • (data): void
      • Parameters

        • data: {
              channel: string;
          }
          • channel: string

            Channel to join

        Returns void

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

    Leave a channel

    Type declaration

      • (data): void
      • Parameters

        • data: {
              channel: string;
          }
          • channel: string

            Channel to leave

        Returns void

    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: ((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: ((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: ((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: ((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: ((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: ((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: ((data) => void)

    Sets a channel topic

    Type declaration

      • (data): void
      • Parameters

        • data: {
              channel: string;
              topic: string;
          }
          • channel: string
          • topic: string

        Returns void

    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: ((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: ((data) => void)

    Sends a chat message to a game

    Type declaration

    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: ((data) => void)

    Type declaration

      • (data): void
      • Parameters

        • data: {
              game_id: number;
          }
          • game_id: number

            The game id

        Returns void

    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: ((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: ((data) => void)

    Type declaration

      • (data): void
      • Parameters

        • data: {
              game_id: number;
          }
          • game_id: number

            The game id

        Returns void

    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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((data) => void)

      Deletes a notification

      Type declaration

        • (data): void
        • Parameters

          • data: {
                notification_id: string;
            }
            • notification_id: string

          Returns void

      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

          Returns {
              error?: string;
              retry?: boolean;
          } | {
              success: true;
          }

      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

          Returns {
              error?: string;
              retry?: boolean;
          } | {
              success: true;
          }

      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: ((data) => void)

      Append a review action to the review log.

      Type declaration

      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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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: ((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