@xmobitea/gn-typescript-client 2.6.13 → 2.6.14

package/dist/runtime/networking/handler/OnGroupMessageUpdateEventHandler.d.ts

@@ -2,13 +2,59 @@ import { Action1 } from "./../../common/Action1";
 import { OperationEvent } from "./../../entity/OperationEvent";
 import { GroupModels } from "./../../entity/models/GroupModels";
 import { IServerEventHandler } from "./IServerEventHandler";
+/**
+ * Decoded payload of the `OnGroupMessageUpdate` server event.
+ *
+ * Pushed by the backend whenever new messages arrive in a group
+ * channel the local client is subscribed to. Use it to drive the
+ * group chat / wall UI in real time.
+ *
+ * Unlike the friend / member events, the payload here is a delta —
+ * `groupMessages` only contains the **new** messages since the last
+ * push, not the full history. The application is expected to append
+ * these to its own log.
+ */
 export declare class GroupMessageUpdate {
+    /**
+     * New group message items the application should append. Each
+     * entry is a fully decoded {@link GroupModels.GroupMessageResponseData}
+     * with sender id, timestamp, body and any embedded metadata.
+     */
     groupMessages: Array<GroupModels.GroupMessageResponseData>;
+    /**
+     * Identifier of the group whose message stream changed.
+     */
     groupId: string;
+    /**
+     * Optional character id when the message update is scoped to a
+     * specific character context (multi-character titles).
+     */
     characterId?: string;
 }
+/**
+ * Auto-registered event handler for the `OnGroupMessageUpdate`
+ * server event.
+ *
+ * Application setup:
+ * ```ts
+ * OnGroupMessageUpdateEventHandler.onUpdate = update => {
+ *     for (const msg of update.groupMessages) appendChat(update.groupId, msg);
+ * };
+ * ```
+ */
 export declare class OnGroupMessageUpdateEventHandler implements IServerEventHandler {
+    /**
+     * Static callback the application registers. Leave `null` to
+     * silently drop incoming messages.
+     */
     static onUpdate: Action1<GroupMessageUpdate>;
+    /**
+     * Returns {@link EventCode.OnGroupMessageUpdate}.
+     */
     getEventCode(): string;
+    /**
+     * Deserialises the parameters into a {@link GroupMessageUpdate}
+     * and forwards to {@link onUpdate}.
+     */
     handle(operationEvent: OperationEvent): void;
 }

package/dist/runtime/networking/http/HttpPeer.d.ts

@@ -1,25 +1,198 @@
 import { Action1 } from "./../../common/Action1";
 import { OperationPending } from "./../OperationPending";
 import { PeerBase } from "./../PeerBase";
+/**
+ * Normalised HTTP response surface used by every HTTP-flavoured
+ * helper inside the SDK.
+ *
+ * Concrete transports ({@link NetworkingPeerAxiosRequest}) populate
+ * the four public fields, then call back into the SDK with this
+ * object. The downstream consumers only have to check
+ * {@link hasError} and `statusCode` before reading either `text`
+ * (JSON-shaped responses) or `data` (binary / MsgPack responses).
+ */
 export declare class HttpAppResponse {
+    /**
+     * HTTP status code as returned by the server. Set to `-1` when
+     * the transport raised an exception before receiving any
+     * response.
+     */
     statusCode: number;
+    /**
+     * Captured transport-level error message, or `null` when the
+     * request succeeded. The presence of this field is what
+     * {@link hasError} branches on.
+     */
     error: string;
+    /**
+     * Raw response body as bytes. Populated only for endpoints that
+     * request binary responses (the MsgPack and upload paths).
+     */
     data: Uint8Array;
+    /**
+     * Response body decoded as text. For JSON endpoints this carries
+     * the JSON string; for MsgPack endpoints this is a best-effort
+     * UTF-8 decode of the bytes used for diagnostic logs only.
+     */
     text: string;
+    /**
+     * Returns whether the transport captured a non-null error
+     * message. Cheaper than checking `error != null` everywhere and
+     * keeps the call sites readable.
+     */
     hasError(): boolean;
+    /**
+     * Returns a debug-friendly stringified summary of the response.
+     *
+     * Used by `[GN Http RECV]` log lines. The `<color=red>` markup
+     * is preserved from the original Unity SDK and rendered by the
+     * Unity console; web consoles display it as plain text.
+     */
     toString(): string;
 }
+/**
+ * HTTP request body encoding used by the SDK.
+ *
+ * Resolved per-request by reading
+ * {@link GNServerSettings.getMessageType} — `MessageType.MsgPack`
+ * maps to {@link MsgPack} on Node.js / Cocos but is downgraded to
+ * {@link Json} in browser runtimes because the browser HTTP path
+ * does not handle binary responses uniformly across vendors.
+ */
 export declare enum PostType {
+    /** UTF-8 JSON request and response bodies. */
     Json = 0,
+    /** Binary MessagePack request and response bodies. */
     MsgPack = 1
 }
+/**
+ * High-level HTTP peer used by {@link NetworkingPeer}.
+ *
+ * Bridges the {@link PeerBase} queue / timeout machinery with the
+ * concrete Axios-based transport in
+ * {@link NetworkingPeerAxiosRequest}. Owns the wire-format selection
+ * (`Json` vs `MsgPack`), URL composition (`/api/<cmd>/<requestType>/
+ * <role>/<operationCode>`) and the JSON-vs-MsgPack response decode
+ * path.
+ *
+ * Browser-vs-Node fallback: when the configured `messageType` is
+ * `MsgPack` and the SDK is running in a browser, this class downgrades
+ * the outgoing request to JSON because the browser path cannot
+ * reliably consume a MsgPack response. A warning is logged on every
+ * such downgrade so the application can surface the mismatch in
+ * development.
+ */
 export declare class HttpPeer extends PeerBase {
+    /** Concrete Axios-based HTTP client. */
     private networkingHttpPeerBase;
+    /**
+     * First character expected on a JSON response body. Used as a
+     * cheap heuristic to decide whether the response should be
+     * `JSON.parse`'d directly or fall through to MsgPack decode.
+     */
     private static readonly JSON_CHAR_KNOWN;
+    /**
+     * Builds and configures the underlying Axios client.
+     *
+     * Steps:
+     * 1. Validate the global server settings.
+     * 2. Capture the `useHttp` flag into {@link isUse} so the queue
+     *    short-circuits when the HTTP transport is disabled.
+     * 3. Allocate {@link NetworkingPeerAxiosRequest} and pass the
+     *    base URL plus the `User-Agent` string built from the SDK
+     *    version + detected platform.
+     * 4. Forward the reverse-proxy flag from the server settings so
+     *    the Axios layer knows whether to inline absolute URLs or
+     *    relative paths.
+     *
+     * @throws Error when the global server settings are missing.
+     */
     protected initGNSocketObject(): void;
+    /**
+     * Sends a queued operation through the underlying HTTP transport.
+     *
+     * Steps:
+     * 1. Substitute the SDK-wide
+     *    {@link OperationRequest.defaultTimeOut} sentinel with the
+     *    configured `defaultTimeoutInSeconds`.
+     * 2. Chain into {@link PeerBase.send} so the in-flight map
+     *    records the request id.
+     * 3. Pick the wire format from the active settings and apply
+     *    the browser MsgPack-to-JSON downgrade described on
+     *    {@link HttpPeer}.
+     * 4. Compose the sub-URI as
+     *    `<api/cmd>/<requestType>/<role>/<operationCode>` using
+     *    {@link CodeHelper} to resolve the camelCase enum names.
+     * 5. Delegate to the Axios transport, then route the response
+     *    through {@link onSendOperationRequestResponse} so the
+     *    inherited {@link PeerBase.onResponseHandler} machinery
+     *    sees a normalised payload.
+     */
     send(operationPending: OperationPending): void;
+    /**
+     * Logs a diagnostic line whenever the queue accepts a new
+     * pending entry. The actual queueing is performed by
+     * {@link PeerBase.enqueue}; this override only adds telemetry.
+     */
     protected onEnqueue(operationPending: OperationPending): void;
+    /**
+     * Decodes a transport-level {@link HttpAppResponse} into the
+     * canonical SDK response container expected by
+     * {@link PeerBase.onResponseHandler}.
+     *
+     * Decode strategy:
+     * - If the body starts with `{` (the {@link JSON_CHAR_KNOWN}
+     *   marker), parse it as JSON.
+     * - Otherwise fall back to MessagePack decode of the binary
+     *   `data` field.
+     *
+     * On any non-200 response or transport error, synthesise a
+     * `ReturnCode.UnknownError` payload that carries the captured
+     * error message in `DebugMessage`. Either path ends with a call
+     * to {@link onResponseHandler} so the higher-level machinery can
+     * resolve the request callback.
+     */
     private onSendOperationRequestResponse;
+    /**
+     * Issues a raw HTTP GET request against the configured base URL.
+     *
+     * Used by the dedicated maintenance endpoints
+     * (`syncTs`, `getAuthInfo`, `healthCheck`) that bypass the
+     * operation-request pipeline because they do not produce a
+     * typed response. The auth token / secret key / game id are
+     * forwarded as request headers, matching the operation-request
+     * pipeline.
+     *
+     * @param subUri          Path appended to the base URL
+     *                        (no leading slash).
+     * @param onHttpAppResponse Callback receiving the typed
+     *                          {@link HttpAppResponse}.
+     * @param timeout         Optional timeout in seconds. Defaults
+     *                        to {@link OperationRequest.defaultTimeOut}.
+     * @param authToken       Optional auth token override.
+     * @param secretKey       Optional secret key override.
+     * @param gameId          Optional game id override.
+     */
     getRequest(subUri: string, onHttpAppResponse: Action1<HttpAppResponse>, timeout?: number, authToken?: string, secretKey?: string, gameId?: string): void;
+    /**
+     * Uploads a file through the authenticated multipart endpoint.
+     *
+     * Aborts immediately with status `401` when no auth token is
+     * cached — the upload endpoint always requires authentication
+     * and the cached token is the only auth source the upload path
+     * recognises (the upload helper does not accept an override).
+     *
+     * @param fileId             Identifier returned by
+     *                           `content.createNewFileUploadInfo`.
+     * @param content            Binary payload.
+     * @param filename           Display name written into the
+     *                           multipart envelope.
+     * @param mimetype           Content type for the file part.
+     * @param onHttpAppResponse  Callback receiving the typed
+     *                           {@link HttpAppResponse}.
+     * @param timeout            Timeout in seconds. Defaults to
+     *                           `6000` so large uploads do not race
+     *                           the SDK-wide 20-second default.
+     */
     uploadFile(fileId: string, content: Uint8Array, filename: string, mimetype: string, onHttpAppResponse: Action1<HttpAppResponse>, timeout?: number): void;
 }

package/dist/runtime/networking/http/NetworkingHttpPeerBase.d.ts

@@ -1,13 +1,100 @@
 import { Action1 } from "./../../common/Action1";
 import { GNHashtable } from "./../../common/GNData";
 import { HttpAppResponse, PostType } from "./HttpPeer";
+/**
+ * Abstract HTTP client contract consumed by {@link HttpPeer}.
+ *
+ * The default — and currently only — implementation is
+ * {@link NetworkingPeerAxiosRequest}, which uses Axios for the actual
+ * network calls. The abstraction exists so future ports can swap in a
+ * different HTTP library (e.g. `fetch`-based for an Edge runtime)
+ * without touching the request queue, response decoding, or wire-
+ * format selection logic in {@link HttpPeer}.
+ *
+ * Lifecycle:
+ * - {@link init} captures the absolute base URL and the SDK's
+ *   `User-Agent` string.
+ * - {@link setUseReverseProxy} mirrors the matching flag from the
+ *   server settings.
+ * - The three abstract methods are invoked by {@link HttpPeer} on
+ *   every send.
+ */
 export declare abstract class NetworkingHttpPeerBase {
+    /** Absolute base URL produced by {@link GNServerSettings.getHttpUrl}. */
     protected httpUrl: string;
+    /**
+     * SDK-issued `User-Agent` value emitted on every Node.js request
+     * (`GN-ts-<platform>@<version>`). Browsers manage their own
+     * `User-Agent` so the value is ignored there.
+     */
     protected userAgent: string;
+    /**
+     * Mirror of {@link GNServerSettings.getUseReverseProxy}. When
+     * `true`, concrete subclasses send relative URLs and forward the
+     * captured base URL through the `X-BaseUrl` header so a
+     * same-origin proxy can rewrite the destination without CORS
+     * preflight.
+     */
     protected useReverseProxy: boolean;
+    /**
+     * Performs an HTTP `GET` against `<httpUrl>/<subUri>`.
+     *
+     * @param subUri            Path appended to the base URL
+     *                          (no leading slash).
+     * @param onHttpAppResponse Callback receiving the normalised
+     *                          {@link HttpAppResponse}.
+     * @param timeout           Timeout in seconds (multiplied by
+     *                          1000 inside the concrete call).
+     * @param authToken         Optional auth token sent in the
+     *                          `Auth-Token` header.
+     * @param secretKey         Optional secret key sent in the
+     *                          `Secret-Key` header.
+     * @param gameId            Optional game id sent in the
+     *                          `Game-Id` header.
+     */
     abstract getRequest(subUri: string, onHttpAppResponse: Action1<HttpAppResponse>, timeout: number, authToken: string, secretKey: string, gameId: string): void;
+    /**
+     * Performs an HTTP `POST` against `<httpUrl>/<subUri>` with
+     * either a JSON or MessagePack body.
+     *
+     * @param subUri            Path appended to the base URL.
+     * @param param             Operation parameter bag.
+     * @param postType          Encoding choice: JSON or MessagePack.
+     * @param onHttpAppResponse Callback receiving the normalised
+     *                          {@link HttpAppResponse}.
+     * @param timeout           Timeout in seconds.
+     * @param authToken         Optional auth token.
+     * @param secretKey         Optional secret key.
+     * @param customTags        Optional routing tags merged into
+     *                          `param` under
+     *                          {@link ParameterCode.CustomTags}.
+     * @param gameId            Optional game id.
+     */
     abstract postRequest(subUri: string, param: GNHashtable, postType: PostType, onHttpAppResponse: Action1<HttpAppResponse>, timeout: number, authToken: string, secretKey: string, customTags: GNHashtable, gameId: string): void;
+    /**
+     * Performs a multipart upload `POST`.
+     *
+     * @param subUri            Path appended to the base URL.
+     * @param content           Binary payload.
+     * @param filename          Display name written into the
+     *                          multipart envelope.
+     * @param mimetype          Content type for the file part.
+     * @param onHttpAppResponse Callback receiving the normalised
+     *                          {@link HttpAppResponse}.
+     * @param timeout           Timeout in seconds.
+     */
     abstract postRequestUpload(subUri: string, content: Uint8Array, filename: string, mimetype: string, onHttpAppResponse: Action1<HttpAppResponse>, timeout: number): void;
+    /**
+     * Captures the base URL and `User-Agent`. Called once during
+     * {@link HttpPeer.initGNSocketObject}.
+     */
     init(httpUrl: string, userAgent: string): void;
+    /**
+     * Toggles reverse-proxy mode on the concrete HTTP client.
+     *
+     * Mirrors {@link GNServerSettings.setUseReverseProxy}; concrete
+     * subclasses inspect the flag every request to decide whether
+     * to send a relative or absolute URL.
+     */
     setUseReverseProxy(useReverseProxy: boolean): void;
 }

package/dist/runtime/networking/http/NetworkingPeerAxiosRequest.d.ts

@@ -2,13 +2,126 @@ import { Action1 } from "./../../common/Action1";
 import { GNHashtable } from "./../../common/GNData";
 import { HttpAppResponse, PostType } from "./HttpPeer";
 import { NetworkingHttpPeerBase } from "./NetworkingHttpPeerBase";
+/**
+ * Concrete HTTP client implemented on top of `axios`.
+ *
+ * Responsibilities:
+ * - Translate the abstract methods on
+ *   {@link NetworkingHttpPeerBase} into Axios calls.
+ * - Apply per-platform tweaks: only emit `User-Agent` and
+ *   `Content-Length` headers from Node.js, because browsers refuse
+ *   to let JavaScript override them.
+ * - Drive the wire format conversion: JSON paths use
+ *   `responseType: "text"`, MsgPack paths use
+ *   `responseType: "arraybuffer"` so the SDK gets bytes back.
+ * - Implement the reverse-proxy URL rewrite: when
+ *   `useReverseProxy === true`, requests are sent as relative paths
+ *   with the original base URL forwarded in the `X-BaseUrl` header.
+ *
+ * Error handling: every Axios `try/catch` collapses the failure into
+ * the {@link HttpAppResponse} surface — `statusCode = -1`,
+ * `error = error.toString()`, `text = "[-2]"` (or `"[-3]"` for
+ * unsupported features). The SDK's higher-level decoder in
+ * {@link HttpPeer.onSendOperationRequestResponse} interprets either
+ * shape correctly.
+ */
 export declare class NetworkingPeerAxiosRequest extends NetworkingHttpPeerBase {
+    /**
+     * @inheritdoc
+     *
+     * Routes through the private async helper so the public method
+     * matches the abstract synchronous-looking signature. The helper
+     * always invokes the callback exactly once.
+     */
     getRequest(subUri: string, onHttpAppResponse: Action1<HttpAppResponse>, timeout: number, authToken: string, secretKey: string, gameId: string): void;
+    /**
+     * @inheritdoc
+     *
+     * Routes through the private async helper. The helper picks the
+     * right Axios call shape for JSON vs MsgPack and converts the
+     * response to either text (JSON) or `Uint8Array` + best-effort
+     * UTF-8 text (MsgPack).
+     */
     postRequest(subUri: string, param: GNHashtable, postType: PostType, onHttpAppResponse: Action1<HttpAppResponse>, timeout: number, authToken: string, secretKey: string, customTags: GNHashtable, gameId: string): void;
+    /**
+     * @inheritdoc
+     *
+     * Routes through the private async helper which constructs the
+     * `FormData` envelope and submits it as
+     * `multipart/form-data`.
+     */
     postRequestUpload(subUri: string, content: Uint8Array, filename: string, mimetype: string, onHttpAppResponse: Action1<HttpAppResponse>, timeout: number): void;
+    /**
+     * Real Axios call for HTTP `GET`.
+     *
+     * Builds the header bag (auth-token / secret-key / game-id /
+     * user-agent), composes the absolute or relative URL based on
+     * the reverse-proxy setting, and asks Axios for an
+     * `arraybuffer` response so binary payloads survive intact.
+     *
+     * On any thrown exception the helper collapses the failure into
+     * an {@link HttpAppResponse} with `statusCode = -1` and
+     * `text = "[-2]"`, then logs through {@link GNDebug.logError}.
+     */
     private getRequestAxios;
+    /**
+     * Real Axios call for HTTP `POST`.
+     *
+     * Wire format selection:
+     * - {@link PostType.Json}: serialise the parameter bag with
+     *   `param.toData()`, send it as JSON, ask Axios for a `text`
+     *   response. `Content-Length` is set explicitly on Node.js so
+     *   reverse proxies that require it work correctly.
+     * - {@link PostType.MsgPack}: encode through
+   *   {@link MessagePackConverterService.serialize}, send as
+   *   `application/msgpack`, ask Axios for an `arraybuffer`
+   *   response.
+     *
+     * Custom tags supplied by the caller are merged into the
+     * outgoing parameter bag under
+     * {@link ParameterCode.CustomTags} so the backend receives them
+     * in the same envelope as the operation parameters.
+     *
+     * Same error-handling shape as {@link getRequestAxios}.
+     */
     private postRequestAxios;
+    /**
+     * Real Axios call for the multipart upload endpoint.
+     *
+     * Builds a `FormData` envelope with a single `file` part — the
+     * field name is taken from {@link Commands.File}, the binary
+     * payload is wrapped in a `Blob` so both browser and Node.js
+     * Axios accept it. The auth token is read from the cached
+     * {@link AuthenticateStatus}; this endpoint cannot accept an
+     * override.
+     *
+     * Note: `content.buffer.slice(0)` clones the underlying buffer
+     * so the upload remains valid if the application later mutates
+     * `content` in place.
+     */
     private postRequestUploadAxios;
+    /**
+     * Decodes a `Uint8Array` to a string using the legacy
+     * `decodeURIComponent(escape(...))` pattern.
+     *
+     * Why the indirection: `String.fromCharCode(...uint8Array)`
+     * produces a Latin-1 string from the bytes, and the
+     * `decodeURIComponent`/`escape` pair re-interprets the result
+     * as UTF-8. Modern equivalents (`TextDecoder`) are not
+     * available across all the supported runtimes (older Cocos
+     * builds, ES5 polyfills) so the SDK keeps the legacy form.
+     */
     private uint8ArrayToString;
+    /**
+     * Normalises an Axios `arraybuffer` body into the
+     * `[Uint8Array, string]` pair stored on
+     * {@link HttpAppResponse}.
+     *
+     * The browser path wraps the `ArrayBuffer` in a `Uint8Array`
+     * and decodes the bytes as UTF-8 via
+     * {@link uint8ArrayToString}. The Node.js path receives a
+     * `Buffer` directly, which already supports `toString()`
+     * cheaply, so it returns the buffer + `buffer.toString()` as is.
+     */
     private toBuffers;
 }

package/dist/runtime/networking/socket/NetworkingPeerSocketIOClient.d.ts

@@ -4,21 +4,166 @@ import { NetworkingSocketPeerBase } from "./NetworkingSocketPeerBase";
 import { RequestType } from "./../../constant/enumType/RequestType";
 import { RequestRole } from "./../../constant/enumType/RequestRole";
 import { GNHashtable } from "./../../common/GNData";
+/**
+ * Concrete socket transport built on top of the official
+ * `socket.io-client` package.
+ *
+ * Wires four inbound socket events to the buffered queues defined on
+ * the parent class:
+ * - `Commands.ResponseCmd_MsgPack` →
+ *   {@link NetworkingSocketPeerBase.responsePacketLst} (binary).
+ * - `Commands.EventCmd_MsgPack` →
+ *   {@link NetworkingSocketPeerBase.eventPacketLst} (binary).
+ * - `Commands.ResponseCmd_Json` → response queue (plain object).
+ * - `Commands.EventCmd_Json` → event queue (plain object).
+ *
+ * Outbound frames are emitted by {@link emit} which converts the
+ * supplied {@link OperationRequest} into the array shape produced by
+ * {@link OperationHelper.toSocketData}, optionally MsgPack-encodes
+ * it via {@link MessagePackConverterService.serialize}, and writes
+ * the matching `Commands.RequestCmd_*` event.
+ *
+ * Connect / disconnect lifecycle: {@link reInitNewSocket} sets up the
+ * `Manager` lazily (only on first call) with `autoConnect: false` so
+ * that {@link connect} controls the actual dial. Inbound `connect` /
+ * `disconnect` / `error` events route into {@link onConnect} /
+ * {@link onDisconnect} / {@link onError} respectively.
+ *
+ * Auth handshake: the SDK does not embed the auth token in the
+ * `Manager` query — instead it emits a dedicated
+ * `Commands.RequestAuthTokenCmd` frame from {@link sendRequestAuthSocket}
+ * once the connect handler fires.
+ */
 export declare class NetworkingPeerSocketIOClient extends NetworkingSocketPeerBase {
+    /** Reused socket.io `Manager` instance (one per SDK lifetime). */
     private socketManager;
+    /** Default namespace socket retrieved from {@link socketManager}. */
     private socket;
+    /**
+     * Local "have we asked for an open connection" flag — used by
+     * {@link connect} to short-circuit redundant dial calls.
+     */
     private isConnected;
+    /**
+     * Sends the cached auth token through the dedicated socket
+     * command so the backend can associate this socket session with
+     * the authenticated user.
+     *
+     * No-op when the socket has not assigned a `clientId` yet — the
+     * SDK retries automatically from {@link onConnectHandler} once
+     * the underlying socket reports `connect`.
+     */
     sendRequestAuthSocket(): void;
+    /**
+     * Lazily allocates the `socket.io-client` `Manager` and registers
+     * every event listener.
+     *
+     * Configuration:
+     * - `path`: derived from the supplied URL by appending the
+     *   `socket.io` segment after whatever path component the URL
+     *   already specifies. This supports both root-level deployments
+     *   (`http://host`) and sub-path deployments
+     *   (`http://host/api/`).
+     * - `reconnection: true` with `reconnectionDelay` from
+     *   {@link GNServerSettings}.
+     * - `timeout: pingTimeout` so the underlying client honours the
+     *   configured heartbeat ceiling.
+     * - `autoConnect: false` so the actual dial happens explicitly
+     *   inside {@link connect}.
+     * - `transports: ["websocket"]` to skip the long-poll fallback;
+     *   the GearN backend always supports WebSocket directly.
+     *
+     * Idempotent — repeated calls after the first succeed are no-ops.
+     */
     reInitNewSocket(): void;
+    /**
+     * Buffers an inbound MessagePack response frame. Decoded later on
+     * the next {@link service} tick.
+     */
     private onResponseMsgPack;
+    /**
+     * Buffers an inbound MessagePack event frame. Decoded later on
+     * the next {@link service} tick.
+     */
     private onEventMsgPack;
+    /**
+     * Buffers an inbound JSON response frame. Decoded later on the
+     * next {@link service} tick.
+     */
     private onResponseJson;
+    /**
+     * Buffers an inbound JSON event frame. Decoded later on the next
+     * {@link service} tick.
+     */
     private onEventJson;
+    /**
+     * Bridges the low-level `connect` event to
+     * {@link onConnectHandler} on the parent class. Captures
+     * `socket.id` as the public {@link clientId}.
+     */
     private onConnect;
+    /**
+     * Bridges the low-level `disconnect` event to
+     * {@link onDisconnectHandler} on the parent class. Clears
+     * {@link clientId} so {@link GNNetwork.isSocketConnected} starts
+     * reporting `false` immediately.
+     */
     private onDisconnect;
+    /**
+     * Logs transport errors via {@link GNDebug.logError}. The SDK
+     * does not propagate transport errors to the application; failed
+     * requests surface through their normal timeout / response-code
+     * path.
+     */
     private onError;
+    /**
+     * Forwards configuration to the parent. The actual `Manager`
+     * allocation is deferred to {@link reInitNewSocket} so the SDK
+     * can re-build the client after a connection drop without
+     * touching the captured configuration.
+     */
     init(url: string, reconnectDelay: number, pingInterval: number, pingTimeout: number): void;
+    /**
+     * Encodes the operation request into the wire shape and emits it
+     * over the active socket.
+     *
+     * Payload preparation:
+     * 1. Merge the supplied `customTags` into the request's
+     *    parameter bag under {@link ParameterCode.CustomTags}.
+     * 2. Convert the request to the array shape via
+     *    {@link OperationHelper.toSocketData} (`[type, role,
+     *    opCode, params]` plus `requestId` when not the
+     *    fire-and-forget sentinel).
+     * 3. Emit the JSON variant directly when `messageType === Json`,
+     *    otherwise encode through MessagePack first.
+     *
+     * Silently no-ops when the underlying `Manager` / default-
+     * namespace `Socket` is unavailable (e.g. before
+     * {@link reInitNewSocket} has run). The intent is best-effort —
+     * any pending-with-callback request will eventually time out and
+     * surface through the regular response handler.
+     */
     protected emit(requestType: RequestType, role: RequestRole, operationRequest: OperationRequest, authToken: string, secretKey: string, customTags: GNHashtable, gameId: string): void;
+    /**
+     * Tears the socket down and notifies subscribers.
+     *
+     * Closes the underlying `Manager` first (the heavy carrier for
+     * the engine.io connection), then disconnects the namespace
+     * socket as a fallback if the manager was never created. After
+     * the underlying client closes, manually invokes
+     * {@link onDisconnectHandler} so the multi-subscriber channel
+     * fires even when the underlying client did not raise a fresh
+     * `disconnect` event (already-closed shortcut path).
+     */
     close(_onSocketDisconnect: Action0): void;
+    /**
+     * Opens the underlying socket.io connection.
+     *
+     * Short-circuits when the SDK has already issued a `connect()`
+     * call (logs "Reconnecting" and returns) so duplicate calls from
+     * application code do not start parallel dials. The first call
+     * dials both the engine.io manager and the default-namespace
+     * socket.
+     */
     connect(_onSocketConnect: Action0): void;
 }