Interface ClientToServer

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

This documenation 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 documenation 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}

Hierarchy

Properties

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;
})

Type declaration

    • (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;
      }
    • 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.

      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

        • 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: {
    uuid: string;
}) => void)

Type declaration

    • (data: {
          uuid: string;
      }): void
    • Cancel a match request

      Parameters

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

      Returns void

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

Type declaration

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

Type declaration

    • (data: {}): void
    • Get active automatch entries for the current user

      Parameters

      • data: {}

        Returns void

    bot/hidden: ((tf: boolean) => void)

    Type declaration

      • (tf: boolean): void
      • Hides or shows a bot in the bot list

        Parameters

        • tf: boolean

        Returns void

    challenge/keepalive: ((data: {
        challenge_id: number;
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            challenge_id: number;
            game_id: number;
        }): 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.

        Parameters

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

        Returns void

    chat/join: ((data: {
        channel: string;
    }) => void)

    Type declaration

      • (data: {
            channel: string;
        }): void
      • Join a chat channel

        Parameters

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

            Channel to join

        Returns void

    chat/part: ((data: {
        channel: string;
    }) => void)

    Type declaration

      • (data: {
            channel: string;
        }): void
      • Leave a channel

        Parameters

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

            Channel to leave

        Returns void

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

    Type declaration

      • (data: {
            message: string;
            player_id: number;
            uid: string;
            username: string;
        }): undefined | {
            from: User;
            message: {
                i: string;
                m: string;
                t: number;
            };
            to: {
                id: number;
                username: string;
            };
        }
      • Send a private message to another user

        Parameters

        • data: {
              message: string;
              player_id: number;
              uid: string;
              username: string;
          }
          • 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: {
        player_id: number;
    }) => void)

    Type declaration

      • (data: {
            player_id: number;
        }): void
      • Closes the current user's private message session with the given player id

        Parameters

        • data: {
              player_id: number;
          }
          • player_id: number

        Returns void

    chat/pm/load: ((data: {
        player_id: number;
    }) => void)

    Type declaration

      • (data: {
            player_id: number;
        }): void
      • Loads the current user's private message session history with the given player id

        Parameters

        • data: {
              player_id: number;
          }
          • player_id: number

        Returns void

    chat/pm/superchat: ((data: {
        enable: boolean;
        player_id: number;
        username: string;
    }) => void)

    Type declaration

      • (data: {
            enable: boolean;
            player_id: number;
            username: string;
        }): 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.

        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: {
        uuid: string;
    }) => void)

    Type declaration

      • (data: {
            uuid: string;
        }): void
      • Moderator only command to remove a single chat message

        Parameters

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

        Returns void

    chat/remove_all: ((data: {
        player_id: number;
    }) => void)

    Type declaration

      • (data: {
            player_id: number;
        }): void
      • Moderator only command to remove all chat messages for a given player

        Parameters

        • data: {
              player_id: number;
          }
          • player_id: number

            Player id to remove all messages for

        Returns void

    chat/send: ((data: {
        channel: string;
        message: string;
        uuid: string;
    }) => void)

    Type declaration

      • (data: {
            channel: string;
            message: string;
            uuid: string;
        }): void
      • Sends a chat message to the given channel

        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: {
        channel: string;
        topic: string;
    }) => void)

    Type declaration

      • (data: {
            channel: string;
            topic: string;
        }): void
      • Sets a channel topic

        Parameters

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

        Returns void

    game/annul: ((data: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): 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 implemeting this.

        Parameters

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

            The game id

        Returns void

    game/cancel: ((data: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): 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 GoEngine.gameCanBeCancelled for cancelation )

        Parameters

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

            The game id

        Returns void

    game/chat: ((data: {
        body: string | GameChatTranslatedMessage | GameChatAnalysisMessage | GameChatReviewMessage;
        game_id: number;
        move_number: number;
        type: "main" | "malkovich" | "moderator" | "hidden" | "personal";
    }) => void)

    Type declaration

    game/chat/remove: ((data: {
        channel: string;
        chat_id: string;
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            channel: string;
            chat_id: string;
            game_id: number;
        }): void
      • Moderator only command to remove a single chat message from a game

        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: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): void
      • Parameters

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

            The game id

        Returns void

    game/conditional_moves/set: ((data: {
        conditional_moves: ConditionalMoveResponse;
        game_id: number;
        move_number: number;
    }) => void)

    Type declaration

      • (data: {
            conditional_moves: ConditionalMoveResponse;
            game_id: number;
            move_number: number;
        }): void
      • Sets conditional moves to be made on behalf of the player in response to a move by the opponent.

        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 condtional moves are rooted in

        Returns void

    game/connect: ((data: {
        chat?: boolean;
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            chat?: boolean;
            game_id: number;
        }): void
      • Connect to a game. Once connected, the client will receive game updates relevant to the game.

        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: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): void
      • Parameters

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

            The game id

        Returns void

    game/disconnect: ((data: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): void
      • Disconnect from a game. This will stop game updates for a particular game.

        Parameters

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

        Returns void

    game/latency: ((data: {
        game_id: number;
        latency: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
            latency: number;
        }): 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.

        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: {
        game_id: number;
    }) => {
        data: any;
        event: string;
        timestamp: string;
    }[])

    Type declaration

      • (data: {
            game_id: number;
        }): {
            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.

        Parameters

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

        Returns {
            data: any;
            event: string;
            timestamp: string;
        }[]

    game/move: ((data: {
        blur?: number;
        clock?: JGOFPlayerClock;
        game_id: number;
        move: string;
    }) => void)

    Type declaration

      • (data: {
            blur?: number;
            clock?: JGOFPlayerClock;
            game_id: number;
            move: string;
        }): void
      • Submit a move for a game

        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: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): void
      • Pauses the game clocks

        Parameters

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

            The game id

        Returns void

    game/removed_stones/accept: ((data: {
        game_id: number;
        stones: string;
        strict_seki_mode: boolean;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
            stones: string;
            strict_seki_mode: boolean;
        }): 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.

        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: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): void
      • Rejects the removed stones and resumes the game from the stone removal phase

        Parameters

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

            The game id

        Returns void

    game/removed_stones/set: ((data: {
        game_id: number;
        removed: boolean;
        stones: string;
        strict_seki_mode?: boolean;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
            removed: boolean;
            stones: string;
            strict_seki_mode?: boolean;
        }): void
      • Sets removed stones in the stone removal phase.

        Parameters

        • data: {
              game_id: number;
              removed: boolean;
              stones: string;
              strict_seki_mode?: boolean;
          }
          • game_id: number

            The game id

          • 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

            String encoded list of intersections

          • 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: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): void
      • Resigns from the game

        Parameters

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

            The game id

        Returns void

    game/resume: ((data: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): void
      • Resumes the game clocks

        Parameters

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

            The game id

        Returns void

    game/timed_out: ((data: {
        game_id: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
        }): 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.

        Parameters

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

            The game id

        Returns void

    game/undo/accept: ((data: {
        game_id: number;
        move_number: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
            move_number: number;
        }): void
      • Accepts an undo

        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: {
        game_id: number;
        move_number: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
            move_number: number;
        }): void
      • Cancels an undo request

        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: {
        game_id: number;
        move_number: number;
    }) => void)

    Type declaration

      • (data: {
            game_id: number;
            move_number: number;
        }): void
      • Requests an undo

        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: {
        channel?: string;
    }) => void)

    Type declaration

      • (data: {
            channel?: string;
        }): void
      • Connects to the game list count. Once connected you'll start receiving gamelist-count or gamelist-count-${channel} messages.

        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: {
        channel?: string;
    }) => void)

    Type declaration

      • (data: {
            channel?: string;
        }): void
      • Disconnects from the game list count

        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: {
        channel?: string;
        from: number;
        limit: number;
        list: "live" | "corr" | "kidsgo";
        sort_by: "rank";
        where: GameListWhere;
    }) => undefined | {
        by: string;
        from: number;
        limit: number;
        list: string;
        results: GameListEntry[];
        size: number;
        where: GameListWhere;
    })

    Type declaration

      • (data: {
            channel?: string;
            from: number;
            limit: number;
            list: "live" | "corr" | "kidsgo";
            sort_by: "rank";
            where: GameListWhere;
        }): undefined | {
            by: string;
            from: number;
            limit: number;
            list: string;
            results: GameListEntry[];
            size: number;
            where: GameListWhere;
        }
      • Queries the server for a list of games

        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;
    })

    Type declaration

      • (data: {}): {
            clients: number;
            ggs-version: string;
            hostname: string;
            uptime: number;
        }
      • Retreive host infomration for the termination server you are connected to

        Parameters

        • data: {}

          Returns {
              clients: number;
              ggs-version: string;
              hostname: string;
              uptime: number;
          }

          • clients: number
          • ggs-version: string
          • hostname: string
          • uptime: number
      itc: ((data: {
          data: any;
          event: string;
      }) => void)

      Type declaration

        • (data: {
              data: any;
              event: string;
          }): 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.

          Parameters

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

              User defined data

            • event: string

              User defined event string

          Returns void

      net/ping: ((data: {
          client: number;
          drift: number;
          latency: number;
      }) => void)

      Type declaration

        • (data: {
              client: number;
              drift: number;
              latency: number;
          }): 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.

          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: {
          notification_id: number;
      }) => void)

      Type declaration

        • (data: {
              notification_id: number;
          }): void
        • Deletes a notification

          Parameters

          • data: {
                notification_id: number;
            }
            • notification_id: number

          Returns void

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

      Type declaration

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

      Type declaration

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

      Type declaration

        • (data: {
              since: string;
          }): {
              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

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

      Type declaration

      review/chat: ((data: {
          body: string;
          from: number;
          moves: string;
          review_id: number;
      }) => void)

      Type declaration

        • (data: {
              body: string;
              from: number;
              moves: string;
              review_id: number;
          }): void
        • Sends a chat message to a review

          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: {
          channel: string;
          chat_id: string;
          review_id: number;
      }) => void)

      Type declaration

        • (data: {
              channel: string;
              chat_id: string;
              review_id: number;
          }): void
        • Moderator only command to remove a single chat message from a game

          Parameters

          • data: {
                channel: string;
                chat_id: string;
                review_id: number;
            }
            • channel: string
            • chat_id: string
            • review_id: number

          Returns void

      review/connect: ((data: {
          review_id: number;
      }) => void)

      Type declaration

        • (data: {
              review_id: number;
          }): void
        • Connects to a review

          Parameters

          • data: {
                review_id: number;
            }
            • review_id: number

              The review id

          Returns void

      review/disconnect: ((data: {
          review_id: number;
      }) => void)

      Type declaration

        • (data: {
              review_id: number;
          }): void
        • Disconnects from a review

          Parameters

          • data: {
                review_id: number;
            }
            • review_id: number

              The review id

          Returns void

      seek_graph/connect: ((data: {
          channel: "global";
      }) => void)

      Type declaration

        • (data: {
              channel: "global";
          }): void
        • Subscribes to the seek graph events. The channel is required to be "global" for now and the foreseeable future.

          Parameters

          • data: {
                channel: "global";
            }
            • channel: "global"

          Returns void

      seek_graph/disconnect: ((data: {
          channel: "global";
      }) => void)

      Type declaration

        • (data: {
              channel: "global";
          }): void
        • Un-Subscribes to the seek graph events. The channel is required to be "global" for now and the foreseeable future.

          Parameters

          • data: {
                channel: "global";
            }
            • channel: "global"

          Returns void

      stats/online: ((data: {
          interval: number;
      }) => number)

      Type declaration

        • (data: {
              interval: number;
          }): number
        • Request the number of unique authenticated players online within the given interval

          Parameters

          • data: {
                interval: number;
            }
            • interval: number

              Interval in seconds

          Returns number

      ui-pushes/subscribe: ((data: {
          channel: string;
      }) => void)

      Type declaration

        • (data: {
              channel: string;
          }): void
        • Subscribes to UI related push event messages sent to a particular channel

          Parameters

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

          Returns void

      ui-pushes/unsubscribe: ((data: {
          channel: string;
      }) => void)

      Type declaration

        • (data: {
              channel: string;
          }): void
        • Un-Subscribes to UI related push event messages sent to a particular channel

          Parameters

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

          Returns void

      user/monitor: ((data: {
          user_ids: number[];
      }) => void)

      Type declaration

        • (data: {
              user_ids: number[];
          }): void
        • Subscribes to online status updates for the given player ids

          Parameters

          • data: {
                user_ids: number[];
            }
            • user_ids: number[]

          Returns void

      Generated using TypeDoc