@xmobitea/gn-typescript-client 2.6.13 → 2.6.14

package/dist/runtime/config/GNServerSettings.d.ts

@@ -1,26 +1,179 @@
 import { LogType } from "./../logger/GNDebug";
+/**
+ * Wire-format selector used by the HTTP and socket transports when they
+ * encode an outgoing payload or decode an incoming one.
+ *
+ * The numeric values are persisted onto the wire indirectly through the
+ * `Commands.RequestCmd_*` / `Commands.ResponseCmd_*` strings, so changing
+ * the underlying ordinal would break every generated request. Treat the
+ * numbers as a stable contract.
+ *
+ * Behavioural notes:
+ * - `Json` is the safest default — every host runtime can encode and decode
+ *   it with no extra dependency. It is also the format used by the
+ *   reverse-proxy paths in {@link NetworkingPeerAxiosRequest}.
+ * - `MsgPack` is preferred on Node.js / Cocos Creator targets where the
+ *   `MessagePackConverterService` runs the `@msgpack/msgpack` codec
+ *   directly. On the browser HTTP path the SDK silently downgrades MsgPack
+ *   responses to JSON because some browsers do not expose the binary
+ *   primitives needed for streamed MsgPack decoding.
+ */
 export declare enum MessageType {
+    /** UTF-8 JSON — universal, slightly larger payloads. */
     Json = 1,
+    /** Binary MessagePack — smaller payloads, requires runtime support. */
     MsgPack = 2
 }
+/**
+ * Strongly-typed shape accepted by {@link GNServerSettings.config}.
+ *
+ * Every field on this interface is **required** because `config()` performs
+ * a full snapshot replacement rather than a merge: it copies each property
+ * verbatim into the {@link GNServerSettings} instance. To do partial
+ * updates use the dedicated `set*` accessors instead.
+ */
 export interface GNServerSettingsOptions {
+    /**
+     * Public host name or IP address of the GearN Server backend.
+     *
+     * No scheme prefix (`http://` / `https://`) and no path — only the host
+     * portion. The transports compose the full URL by combining this value
+     * with `useSsl`, `serverPort` (HTTP) and `serverSocketPort` (socket).
+     *
+     * Example: `"api.example.com"` or `"10.0.0.5"`.
+     */
     serverAddress: string;
+    /**
+     * Public TCP port that exposes the GearN HTTP API.
+     *
+     * Use `-1` when a reverse proxy makes the API available on the default
+     * port for the chosen scheme (80 / 443) — the URL builder in
+     * {@link GNServerSettings.getHttpUrl} omits the port segment in that
+     * case so the browser does not append `:80` / `:443` redundantly.
+     */
     serverPort: number;
+    /**
+     * Public TCP port that exposes the GearN socket.io endpoint.
+     *
+     * Use `-1` for proxy setups for the same reason as `serverPort`.
+     */
     serverSocketPort: number;
+    /**
+     * When `true`, the URL builders emit `https://` and `wss://` schemes,
+     * otherwise `http://` and `ws://`. Switching this value at runtime
+     * affects the next `getHttpUrl()` / `getSocketUrl()` call but does not
+     * upgrade an already-open socket.io connection.
+     */
     useSsl: boolean;
+    /**
+     * Master switch for the realtime socket.io transport.
+     *
+     * When `false`, {@link SocketPeer.initGNSocketObject} sets `isUse` to
+     * `false` and every `enqueue` call routed at the socket peer is dropped
+     * with an error logged through `GNDebug.logError`.
+     */
     useSocket: boolean;
+    /**
+     * Master switch for the HTTP transport. When `false` the typed API
+     * wrappers in `GNNetwork*Api` will fail to send because their
+     * underlying `enqueue` calls are no-ops on a disabled peer.
+     */
     useHttp: boolean;
+    /**
+     * Default request timeout (in **seconds**) applied by both transports
+     * whenever an `OperationRequest` is constructed without an explicit
+     * timeout override. The shared `OperationRequest.defaultTimeOut`
+     * sentinel (also `20`) is what triggers this fallback inside
+     * {@link SocketPeer.send}.
+     */
     defaultTimeoutInSeconds: number;
+    /**
+     * Preferred wire format. See {@link MessageType} for the runtime caveats
+     * (the browser HTTP path may downgrade MsgPack responses to JSON).
+     */
     messageType: MessageType;
+    /**
+     * Maximum number of operation requests the SDK will pop from the local
+     * queue per second. The transports convert this value into a
+     * per-message tick duration (`perMsgTimer = 1 / sendRate / 1000`)
+     * inside {@link PeerBase.setSendRate}, which the `service()` loop uses
+     * as a throttle.
+     *
+     * Practical range is 5..50; values lower than 5 introduce noticeable
+     * head-of-line latency on bursts.
+     */
     sendRate: number;
+    /**
+     * Reconnect backoff delay (in **milliseconds**) handed to the
+     * underlying socket.io client after an unexpected disconnection.
+     */
     reconnectDelay: number;
+    /**
+     * Heartbeat interval (in **milliseconds**) used by the socket.io
+     * client to keep the connection alive across NAT timeouts.
+     */
     pingInterval: number;
+    /**
+     * Maximum waiting time (in **milliseconds**) for a heartbeat response
+     * before the socket.io client treats the link as dead and triggers
+     * `disconnect`.
+     */
     pingTimeout: number;
-    adminSecretKey: string;
-    serverSecretKey: string;
-    clientSecretKey: string;
+    /**
+     * Per-game shared secret. The transports forward this value in the
+     * `Secret-Key` HTTP header / equivalent socket frame so the backend
+     * can authenticate the SDK origin before processing the operation.
+     */
+    secretKey: string;
+    /**
+     * GearN game identifier. Sent in the `Game-Id` HTTP header by every
+     * authenticated request so the backend can route to the right game
+     * configuration.
+     */
+    gameId: string;
+    /**
+     * Initial verbosity level for {@link GNDebug}. Applied by
+     * `GNNetwork.initGNDebug()` shortly after `init()` is called.
+     */
     logType: LogType;
 }
+/**
+ * Mutable configuration container shared between {@link GNNetwork}, the
+ * HTTP peer ({@link HttpPeer}) and the socket peer ({@link SocketPeer}).
+ *
+ * Intended usage:
+ * ```ts
+ * const settings = new GNServerSettings();
+ * settings.config({
+ *   serverAddress: "api.example.com",
+ *   serverPort: 443,
+ *   serverSocketPort: 443,
+ *   useSsl: true,
+ *   useSocket: true,
+ *   useHttp: true,
+ *   defaultTimeoutInSeconds: 20,
+ *   messageType: MessageType.MsgPack,
+ *   sendRate: 20,
+ *   reconnectDelay: 5000,
+ *   pingInterval: 20000,
+ *   pingTimeout: 20000,
+ *   secretKey: "<game-secret>",
+ *   gameId: "<game-id>",
+ *   logType: LogType.All,
+ * });
+ * GNNetwork.init(settings);
+ * ```
+ *
+ * Lifecycle notes:
+ * - `GNNetwork.init()` stores a reference to the instance you pass in and
+ *   never copies it, so subsequent `set*` calls remain visible to the
+ *   transports. URL-affecting changes (`setServerAddress`, `setUseSsl`,
+ *   port setters) take effect on the very next request, but **do not**
+ *   reconnect an already-open socket.io session.
+ * - The default values defined inline below (host `127.0.0.1`, port
+ *   `2202` / `2901`, MsgPack, etc.) match the GearN Server local-dev
+ *   defaults.
+ */
 export declare class GNServerSettings {
     private serverAddress;
     private serverPort;
@@ -34,46 +187,323 @@ export declare class GNServerSettings {
     private reconnectDelay;
     private pingInterval;
     private pingTimeout;
-    private adminSecretKey;
-    private serverSecretKey;
-    private clientSecretKey;
+    private secretKey;
+    private gameId;
     private logType;
     private useReverseProxy;
+    /**
+     * Replaces every configurable value in the instance with the snapshot
+     * provided by `options`.
+     *
+     * This is **not** a partial merge: every field on
+     * {@link GNServerSettingsOptions} is required and is copied verbatim.
+     * To change a single value at runtime use the dedicated `set*`
+     * accessor instead.
+     *
+     * `useReverseProxy` is intentionally **not** part of the snapshot
+     * because it is configured separately via
+     * {@link setUseReverseProxy} during transport-specific tuning.
+     *
+     * @param options Full configuration snapshot. See the field-level
+     *                documentation on {@link GNServerSettingsOptions} for
+     *                units and accepted ranges.
+     */
     config(options: GNServerSettingsOptions): void;
+    /**
+     * Returns the configured host name or IP address.
+     *
+     * The value is the bare host (no scheme, no path, no port) used by
+     * {@link getHttpUrl} and {@link getSocketUrl} when they compose the
+     * absolute URL passed to Axios / socket.io.
+     *
+     * @returns Current host string. Defaults to `127.0.0.1` until
+     *          `config()` or `setServerAddress()` overrides it.
+     */
     getServerAddress(): string;
+    /**
+     * Updates the host name or IP address used by both transports.
+     *
+     * Takes effect on the next URL build — does not reconnect an already
+     * open socket.io session.
+     *
+     * @param serverAddress Bare host (no scheme, no port).
+     */
     setServerAddress(serverAddress: string): void;
+    /**
+     * Returns the TCP port used to compose the HTTP base URL.
+     *
+     * @returns The port number. A value of `-1` is the convention for
+     *          "default port for the scheme" and causes {@link getHttpUrl}
+     *          to omit the port segment from the URL.
+     */
     getServerPort(): number;
+    /**
+     * Updates the HTTP port used to compose the base API URL.
+     *
+     * @param serverPort TCP port, or `-1` to fall back to the default port
+     *                   of the current scheme (80 for HTTP, 443 for HTTPS).
+     */
     setServerPort(serverPort: number): void;
+    /**
+     * Returns the TCP port used to compose the socket base URL.
+     *
+     * @returns The port number, or `-1` when the application wants the URL
+     *          builder to omit the port segment.
+     */
     getServerSocketPort(): number;
+    /**
+     * Updates the socket port used to compose the socket URL.
+     *
+     * @param serverSocketPort TCP port, or `-1` to omit the port segment.
+     */
     setServerSocketPort(serverSocketPort: number): void;
+    /**
+     * Returns whether the URL builders should emit `https://` / `wss://`.
+     *
+     * @returns `true` when SSL is enabled, `false` otherwise.
+     */
     isUseSsl(): boolean;
+    /**
+     * Enables or disables HTTPS / WSS URL generation.
+     *
+     * Does **not** retroactively upgrade an already open socket.io session
+     * — call {@link disconnectSocket} then {@link connectSocket} on
+     * `GNNetwork` to apply the change to the realtime channel.
+     *
+     * @param useSsl `true` to use the secure schemes, `false` to use the
+     *               clear-text schemes.
+     */
     setUseSsl(useSsl: boolean): void;
+    /**
+     * Returns whether the socket transport is enabled.
+     *
+     * When `false`, {@link SocketPeer} marks itself as unusable and every
+     * realtime feature (event push, low-latency send) is disabled.
+     *
+     * @returns `true` when the socket transport is enabled.
+     */
     isUseSocket(): boolean;
+    /**
+     * Enables or disables the realtime socket transport.
+     *
+     * Read at peer-init time only — toggling this value after
+     * `GNNetwork.init()` will **not** start or stop the underlying
+     * socket.io client, only freshly initialised peers honour it.
+     *
+     * @param useSocket Master switch for the realtime channel.
+     */
     setUseSocket(useSocket: boolean): void;
+    /**
+     * Returns whether the HTTP transport is enabled.
+     *
+     * @returns `true` when HTTP transport is enabled.
+     */
     isUseHttp(): boolean;
+    /**
+     * Enables or disables the HTTP transport.
+     *
+     * Read at peer-init time only — disabling HTTP after
+     * `GNNetwork.init()` will not unbind Axios but will cause every
+     * subsequent typed API call to fail with an error log because the
+     * peer's `isUse` flag is checked at enqueue time.
+     *
+     * @param useHttp Master switch for the HTTP channel.
+     */
     setUseHttp(useHttp: boolean): void;
+    /**
+     * Returns the default request timeout in **seconds**.
+     *
+     * Applied by {@link SocketPeer.send} to any operation request whose
+     * timeout still equals the {@link OperationRequest.defaultTimeOut}
+     * sentinel.
+     *
+     * @returns Timeout in seconds. Defaults to `20`.
+     */
     getDefaultTimeoutInSeconds(): number;
+    /**
+     * Updates the default request timeout in **seconds**.
+     *
+     * Only affects operations that did not specify their own timeout when
+     * they were created.
+     *
+     * @param defaultTimeoutInSeconds Timeout in seconds. Use values that
+     *                                cover both the network round-trip and
+     *                                server processing time.
+     */
     setDefaultTimeoutInSeconds(defaultTimeoutInSeconds: number): void;
+    /**
+     * Returns the preferred wire format.
+     *
+     * @returns The currently selected {@link MessageType}. Note that the
+     *          browser HTTP path silently downgrades MsgPack responses to
+     *          JSON for compatibility reasons.
+     */
     getMessageType(): MessageType;
+    /**
+     * Updates the preferred wire format.
+     *
+     * The change applies to subsequent requests; in-flight requests
+     * already serialised remain in their original format.
+     *
+     * @param messageType New wire format.
+     */
     setMessageType(messageType: MessageType): void;
+    /**
+     * Returns the throttle applied by the local request queue.
+     *
+     * @returns Maximum number of messages dispatched per second.
+     *          Defaults to `20`.
+     */
     getSendRate(): number;
+    /**
+     * Updates the local-queue throttle.
+     *
+     * Only honoured at peer-init time — already-running peers keep using
+     * the rate they captured during {@link PeerBase.initSendRate}.
+     *
+     * @param sendRate Maximum messages per second. Practical range is
+     *                 `5..50`; very low values introduce noticeable
+     *                 head-of-line latency under burst load.
+     */
     setSendRate(sendRate: number): void;
+    /**
+     * Returns the socket reconnect delay.
+     *
+     * @returns Delay in **milliseconds** before the socket.io client
+     *          attempts a reconnect after an unexpected drop.
+     */
     getReconnectDelay(): number;
+    /**
+     * Updates the socket reconnect delay.
+     *
+     * Read once when {@link SocketPeer.initGNSocketObject} hands the value
+     * to the underlying socket.io client. Setting it later requires a
+     * disconnect/reconnect cycle to take effect.
+     *
+     * @param reconnectDelay Delay in **milliseconds**.
+     */
     setReconnectDelay(reconnectDelay: number): void;
+    /**
+     * Returns the socket heartbeat interval.
+     *
+     * @returns Interval in **milliseconds**.
+     */
     getPingInterval(): number;
+    /**
+     * Updates the socket heartbeat interval.
+     *
+     * Read once when the socket.io client is configured. Setting it later
+     * requires reconnect.
+     *
+     * @param pingInterval Interval in **milliseconds**.
+     */
     setPingInterval(pingInterval: number): void;
+    /**
+     * Returns the socket heartbeat timeout.
+     *
+     * @returns Maximum waiting time in **milliseconds** for a heartbeat
+     *          response before the link is considered dead.
+     */
     getPingTimeout(): number;
+    /**
+     * Updates the socket heartbeat timeout.
+     *
+     * Read once when the socket.io client is configured. Setting it later
+     * requires reconnect.
+     *
+     * @param pingTimeout Timeout in **milliseconds**.
+     */
     setPingTimeout(pingTimeout: number): void;
-    getAdminSecretKey(): string;
-    setAdminSecretKey(adminSecretKey: string): void;
-    getServerSecretKey(): string;
-    setServerSecretKey(serverSecretKey: string): void;
-    getClientSecretKey(): string;
-    setClientSecretKey(clientSecretKey: string): void;
+    /**
+     * Returns the secret key sent in the `Secret-Key` HTTP header.
+     *
+     * @returns Current secret key. Empty / `undefined` when the
+     *          application has not configured one yet.
+     */
+    getSecretKey(): string;
+    /**
+     * Updates the secret key sent in the `Secret-Key` HTTP header.
+     *
+     * Take care not to commit production secrets into source control —
+     * load this value from a secure environment variable or remote config
+     * service before passing it into `config()` or this setter.
+     *
+     * @param secretKey Game-specific shared secret.
+     */
+    setSecretKey(secretKey: string): void;
+    /**
+     * Returns the game id sent in the `Game-Id` HTTP header.
+     *
+     * @returns Current game id, or `undefined` when not yet configured.
+     */
+    getGameId(): string;
+    /**
+     * Updates the game id sent in the `Game-Id` HTTP header.
+     *
+     * @param gameId Identifier configured for this game on the GearN
+     *               backend.
+     */
+    setGameId(gameId: string): void;
+    /**
+     * Returns the verbosity level forwarded to {@link GNDebug}.
+     *
+     * @returns The currently configured {@link LogType}.
+     */
     getLogType(): LogType;
+    /**
+     * Updates the verbosity level forwarded to {@link GNDebug}.
+     *
+     * Note: this setter only updates the snapshot stored on this instance.
+     * `GNDebug.setLogType` is invoked once during `GNNetwork.init()`; to
+     * change the live log level afterwards call `GNDebug.setLogType`
+     * directly in addition to this setter.
+     *
+     * @param logType New level. See {@link LogType} for the inclusion table.
+     */
     setLogType(logType: LogType): void;
+    /**
+     * Builds the absolute base URL for the socket transport.
+     *
+     * The result is composed of `scheme + "://" + host` and, when
+     * `serverSocketPort >= 0`, also `":" + port`. The scheme is `https`
+     * when {@link useSsl} is `true`, otherwise `http`. socket.io uses the
+     * HTTP scheme — it negotiates the `ws://` / `wss://` upgrade itself.
+     *
+     * @returns Absolute base URL passed to the socket.io client during
+     *          {@link SocketPeer.initGNSocketObject}.
+     */
     getSocketUrl(): string;
+    /**
+     * Builds the absolute base URL for the HTTP transport.
+     *
+     * Composition mirrors {@link getSocketUrl}: scheme + host + optional
+     * `":" + port`. Used by {@link NetworkingPeerAxiosRequest} to prefix
+     * the operation-specific sub-URI before the actual Axios call.
+     *
+     * @returns Absolute HTTP base URL — does **not** include a trailing
+     *          slash, callers append `"/" + subUri` themselves.
+     */
     getHttpUrl(): string;
+    /**
+     * Toggles reverse-proxy mode for the HTTP transport.
+     *
+     * When enabled the Axios layer drops the absolute URL and instead
+     * sends the request as a relative path (`"/" + subUri`), forwarding
+     * the original base URL through the `X-BaseUrl` header so a
+     * same-origin proxy can rewrite it. This is mainly useful for browser
+     * applications that want to avoid CORS preflight.
+     *
+     * @param useReverseProxy `true` to route HTTP traffic through a
+     *                        same-origin proxy, `false` to use the
+     *                        absolute URL built from the configured host
+     *                        and port.
+     */
     setUseReverseProxy(useReverseProxy: boolean): void;
+    /**
+     * Returns whether HTTP requests should be routed through a same-origin
+     * reverse proxy.
+     *
+     * @returns `true` when reverse-proxy mode is active.
+     */
     getUseReverseProxy(): boolean;
 }

package/dist/runtime/constant/Commands.d.ts

@@ -1,20 +1,100 @@
+/**
+ * Wire-format string constants used by both transports.
+ *
+ * Centralises HTTP header names, content-type values, socket
+ * command identifiers and multipart field names. The values are
+ * the literal strings the GearN backend recognises on the wire,
+ * so they cannot be renamed without a coordinated backend change.
+ *
+ * Categories:
+ * - `USER_AGENT`, `CONTENT_TYPE`, `ACCEPT`, `CONTENT_LENGTH` —
+ *   generic HTTP headers consumed by
+ *   {@link NetworkingPeerAxiosRequest}.
+ * - `APPLICATION_JSON`, `APPLICATION_MSGPACK` — MIME values for
+ *   the matching wire format.
+ * - `RequestAuthTokenCmd`, `RequestSecretCmd`, `RequestGameIdCmd` —
+ *   GearN-specific HTTP headers (also used as the auth-frame name
+ *   on the socket transport).
+ * - `RequestCmd_*`, `ResponseCmd_*`, `EventCmd_*` — socket.io
+ *   event names for outbound requests, inbound responses and
+ *   inbound server-pushed events. Two flavours each (MsgPack
+ *   binary vs JSON text).
+ * - `Data`, `File` — multipart form-data field names for the
+ *   upload endpoint.
+ * - `BaseUrl` — reverse-proxy header that forwards the original
+ *   base URL when relative-path mode is enabled.
+ */
 export declare class Commands {
+    /**
+     * HTTP header used to identify the SDK client variant and version.
+     */
     static readonly USER_AGENT: string;
+    /**
+     * HTTP header that declares the request body content type.
+     */
     static readonly CONTENT_TYPE: string;
+    /**
+     * HTTP header that declares which response content types the client accepts.
+     */
     static readonly ACCEPT: string;
+    /**
+     * HTTP header that carries the serialized request body size in bytes when required.
+     */
     static readonly CONTENT_LENGTH: string;
+    /**
+     * MIME type used for JSON request and response payloads.
+     */
     static readonly APPLICATION_JSON: string;
+    /**
+     * MIME type used for MessagePack request and response payloads.
+     */
     static readonly APPLICATION_MSGPACK: string;
+    /**
+     * Transport header used to send the current auth token with HTTP requests.
+     */
     static readonly RequestAuthTokenCmd: string;
+    /**
+     * Transport header used to send the selected route secret key with HTTP requests.
+     */
     static readonly RequestSecretCmd: string;
+    /**
+     * Transport header used to send the current game id when the backend requires it.
+     */
     static readonly RequestGameIdCmd: string;
+    /**
+     * Socket command name for MessagePack operation requests.
+     */
     static readonly RequestCmd_MsgPack: string;
+    /**
+     * Socket command name for MessagePack operation responses.
+     */
     static readonly ResponseCmd_MsgPack: string;
+    /**
+     * Socket command name for MessagePack pushed events.
+     */
     static readonly EventCmd_MsgPack: string;
+    /**
+     * Socket command name for JSON operation requests.
+     */
     static readonly RequestCmd_Json: string;
+    /**
+     * Socket command name for JSON operation responses.
+     */
     static readonly ResponseCmd_Json: string;
+    /**
+     * Socket command name for JSON pushed events.
+     */
     static readonly EventCmd_Json: string;
+    /**
+     * Multipart field name used for non-file payload data.
+     */
     static readonly Data: string;
+    /**
+     * Multipart field name used for uploaded file content.
+     */
     static readonly File: string;
+    /**
+     * Reverse-proxy helper header that carries the original base URL when needed.
+     */
     static readonly BaseUrl: string;
 }

package/dist/runtime/constant/EventCode.d.ts

@@ -1,8 +1,56 @@
+/**
+ * String identifiers for every realtime event the GearN backend
+ * pushes to authenticated socket clients.
+ *
+ * The values are the camelCase names embedded in the wire frame's
+ * `eventCode` parameter. The SDK uses them as the dictionary key
+ * inside {@link SocketPeer.serverEventHandlersDict} when it
+ * dispatches an inbound event to the registered
+ * {@link IServerEventHandler} implementations.
+ *
+ * Application code typically does not read these values directly
+ * — register a typed handler from
+ * `runtime/networking/handler/On*EventHandler.ts` instead, which
+ * already wires the matching event code through
+ * `getEventCode()`.
+ *
+ * Adding a new event: declare a new `public static readonly`
+ * entry here, write a typed handler that returns it from
+ * `getEventCode()`, and decorate the handler with
+ * `@IServerEventHandler.registerEvent`.
+ */
 export declare class EventCode {
+    /**
+     * Account-level (master-player) friend roster changed —
+     * decoded by
+     * {@link OnGamePlayerFriendUpdateEventHandler}.
+     */
     static readonly OnGamePlayerFriendUpdate: string;
+    /**
+     * Character-scoped friend roster changed — decoded by
+     * {@link OnCharacterPlayerFriendUpdateEventHandler}.
+     */
     static readonly OnCharacterPlayerFriendUpdate: string;
+    /**
+     * Account-level group membership changed — decoded by
+     * {@link OnGamePlayerGroupUpdateEventHandler}.
+     */
     static readonly OnGamePlayerGroupUpdate: string;
+    /**
+     * Group member roster changed — decoded by
+     * {@link OnGroupMemberUpdateEventHandler}. Pushed to every
+     * client currently subscribed to the group.
+     */
     static readonly OnGroupMemberUpdate: string;
+    /**
+     * Group message stream received new entries — decoded by
+     * {@link OnGroupMessageUpdateEventHandler}. Payload is a
+     * delta (only the new messages), not the full history.
+     */
     static readonly OnGroupMessageUpdate: string;
+    /**
+     * Character-scoped group membership changed — decoded by
+     * {@link OnCharacterPlayerGroupUpdateEventHandler}.
+     */
     static readonly OnCharacterPlayerGroupUpdate: string;
 }