@xmobitea/gn-typescript-client 2.6.13 → 2.6.14

package/dist/runtime/networking/PeerBase.d.ts

@@ -6,26 +6,257 @@ import { OperationRequest } from "./../entity/OperationRequest";
 import { OperationResponse } from "./../entity/OperationResponse";
 import { IPeer } from "./IPeer";
 import { OperationPending } from "./OperationPending";
+/**
+ * Shared scaffolding for both transports — owns the request queue,
+ * tracks in-flight operations, sweeps timeouts and parses raw response
+ * payloads into typed {@link OperationResponse} instances.
+ *
+ * Subclasses ({@link HttpPeer}, {@link SocketPeer}) only need to:
+ * - Implement {@link initGNSocketObject} so they can build their
+ *   transport-specific low-level client (Axios / socket.io).
+ * - Implement {@link onEnqueue} to react when a request is queued
+ *   (typically a debug log line; the socket peer also wakes itself
+ *   up from idle).
+ * - Override {@link send} to dispatch the actual frame, then chain
+ *   into `super.send(...)` so the in-flight tracking logic still
+ *   runs.
+ *
+ * Driver loop: {@link service} is called from {@link ServiceUpdate}
+ * on a fixed interval. Each tick:
+ * 1. Every 0.1 s sweeps the in-flight map and synthesises a
+ *    `ReturnCode.OperationTimeout` response for every pending entry
+ *    whose absolute deadline has elapsed.
+ * 2. Drains at most one queued request per tick when the
+ *    rate-limiter (`perMsgTimer`) permits, so the SDK never floods
+ *    the backend even when the application bursts dozens of
+ *    requests at once.
+ *
+ * Auth token / user id mirror: {@link onResponseHandler} silently
+ * forwards any `authToken`, `userId` or `ts` parameter found inside a
+ * successful response into both {@link AuthenticateStatus} and
+ * {@link StorageService}, so a process restart can resume the prior
+ * session without an explicit re-login.
+ */
 export declare abstract class PeerBase implements IPeer {
+    /**
+     * FIFO queue of requests waiting to be sent. Drained one entry
+     * per `service()` tick when the rate limiter allows.
+     */
     private operationPendingQueue;
+    /**
+     * In-flight set keyed by the request id assigned at enqueue time.
+     * Only requests that registered a callback go in here — callbacks
+     * are mandatory for response correlation, so fire-and-forget
+     * entries are not tracked.
+     */
     private operationWaitingResponseDict;
+    /**
+     * Monotonic counter used to assign unique request ids to outgoing
+     * operations. Static so HTTP and socket peers share the same id
+     * space, which makes log lines easier to correlate when the SDK
+     * runs both transports concurrently.
+     */
     private static requestId;
+    /**
+     * Effective time between sends, derived from the configured
+     * `sendRate` via `1 / sendRate / 1000`. Note the unusual unit:
+     * the value is **seconds-per-message divided by 1000**, which
+     * matches the rest of the seconds-based comparisons in
+     * {@link service}.
+     */
     private perMsgTimer;
+    /**
+     * Earliest time the next queued request may be sent. Updated each
+     * time a request leaves the queue.
+     */
     private nextSendMsgTimer;
+    /**
+     * Earliest time the next timeout sweep may run. The sweep cadence
+     * is fixed at 100 ms regardless of the configured `sendRate`.
+     */
     private checkTimeoutOperationPending;
+    /**
+     * Returns the configured send rate as a messages-per-second value.
+     *
+     * The internal storage uses an unusual unit; this helper restores
+     * the human-readable rate so any external diagnostics can display
+     * the value the application configured.
+     */
     protected getSendRate(): number;
+    /**
+     * Translates a messages-per-second rate into the internal
+     * per-message tick used by {@link service}.
+     *
+     * Called once during {@link initSendRate}; mutating it after that
+     * has no effect on already-running peers because the value is
+     * captured during init.
+     *
+     * @param sendRate Messages per second from
+     *                 {@link GNServerSettings.getSendRate}.
+     */
     protected setSendRate(sendRate: number): void;
+    /**
+     * Most recent average latency in milliseconds. Computed from the
+     * sliding window in {@link addPing} as half of the round-trip
+     * (one-way), and surfaced through {@link NetworkingPeer.getPing}
+     * / {@link GNNetwork.getPing}.
+     *
+     * Stays `undefined` until at least one successful response has
+     * been observed; readers should treat that case as "no data".
+     */
     ping: number;
+    /**
+     * Sliding window of the last 10 measured one-way latencies (in
+     * milliseconds). Older entries are dropped from the head as new
+     * measurements arrive.
+     */
     private pingLst;
+    /**
+     * Reflects the matching `useHttp` / `useSocket` flag from
+     * {@link GNServerSettings}. Set during {@link initGNSocketObject}
+     * and re-checked at every {@link enqueue} / {@link service} call
+     * so a transport disabled by configuration drops new requests
+     * with a clear error log.
+     */
     protected isUse: boolean;
+    /**
+     * One-shot bootstrap called from
+     * {@link NetworkingPeer.initPeer}.
+     *
+     * Allocates the queue and in-flight map (idempotent — repeats are
+     * no-ops because the existing references are reused), reads the
+     * configured send rate and finally lets the concrete subclass
+     * build its low-level transport via {@link initGNSocketObject}.
+     */
     initPeer(): void;
+    /**
+     * Reads the send rate from the shared
+     * {@link GNServerSettings} and translates it into the internal
+     * tick value through {@link setSendRate}.
+     *
+     * @throws Error when the SDK is used before
+     *         {@link GNNetwork.init} has populated the settings
+     *         singleton.
+     */
     private initSendRate;
+    /**
+     * Subclass hook for transport-specific client setup.
+     *
+     * Implementations build the underlying socket.io / Axios client,
+     * read the matching `useHttp` / `useSocket` switch, register the
+     * transport-specific event/response listeners, and finally set
+     * {@link isUse} to control whether the queue accepts requests.
+     */
     protected abstract initGNSocketObject(): void;
+    /**
+     * Wraps a request in an {@link OperationPending} entry and pushes
+     * it onto the FIFO queue.
+     *
+     * The peer assigns a fresh request id by incrementing the static
+     * counter only when the request was created with the non-default
+     * id (the constant `-1` opts out so the request becomes
+     * fire-and-forget on the wire). Disabled transports
+     * (`isUse === false`) drop the call with an error log so the
+     * application can spot the misconfiguration during development.
+     *
+     * @param requestType         Logical request category.
+     * @param role                Permission scope to evaluate against
+     *                            the auth token.
+     * @param operationRequest    Pre-built request to enqueue.
+     * @param onOperationResponse Optional response callback.
+     * @param authToken           Auth token to attach to this
+     *                            request. Caller code normally lets
+     *                            {@link NetworkingPeer.sendViaSocket}
+     *                            / `sendViaHttp` substitute the
+     *                            cached value when the override is
+     *                            `null`.
+     * @param secretKey           Shared secret for the
+     *                            `Secret-Key` header.
+     * @param customTags          Optional routing tags.
+     * @param gameId              Game id for the `Game-Id` header.
+     */
     enqueue(requestType: RequestType, role: RequestRole, operationRequest: OperationRequest, onOperationResponse: Action1<OperationResponse>, authToken: string, secretKey: string, customTags: GNHashtable, gameId: string): void;
+    /**
+     * Subclass hook fired immediately after a new pending entry lands
+     * in the queue.
+     *
+     * Used by both transports for diagnostic log lines; the socket
+     * peer additionally relies on this to nudge any sleeping send
+     * scheduler awake.
+     */
     protected abstract onEnqueue(operationPending: OperationPending): void;
+    /**
+     * Returns whether the transport is currently enabled.
+     */
     isUsing(): boolean;
+    /**
+     * Drives one tick of the request pipeline.
+     *
+     * Steps performed every tick:
+     * - Every 100 ms, synthesise a `ReturnCode.OperationTimeout`
+     *   response for any in-flight operation whose absolute timeout
+     *   has elapsed. The synthesised response carries `null`
+     *   parameters and the original `requestId` so
+     *   {@link onResponseHandler} routes it to the right callback.
+     * - When the rate-limit timer permits, pop the head of the queue
+     *   and dispatch it through {@link send}.
+     *
+     * Disabled transports short-circuit immediately — no timeout
+     * sweep, no send.
+     */
     service(): void;
+    /**
+     * Decodes a raw response payload, builds the typed
+     * {@link OperationResponse}, mirrors any newly issued auth token
+     * / user id / server timestamp into the cache and persistent
+     * storage, and finally invokes the registered callback.
+     *
+     * Mirror behaviour:
+     * - `ParameterCode.AuthToken` →
+     *   {@link AuthenticateStatus.setAuthToken} +
+     *   `StorageService.setString(GNNetwork.AUTH_TOKEN_KEY, ...)`.
+     * - `ParameterCode.UserId` →
+     *   {@link AuthenticateStatus.setUserId} +
+     *   `StorageService.setString(GNNetwork.USER_ID_KEY, ...)`.
+     * - `ParameterCode.Ts` →
+     *   {@link NetworkingPeer.setServerTimeMilliseconds}.
+     *
+     * The mirror only runs for responses where `hasError()` returns
+     * `false`, so an authentication failure does not poison the cache.
+     *
+     * @param obj Raw response container as decoded by the transport
+     *            layer. Carries `ResponseId`, `ReturnCode`,
+     *            `Parameters`, `DebugMessage` and the optional
+     *            `InvalidRequestParameters` array.
+     */
     protected onResponseHandler(obj: GNHashtable): void;
+    /**
+     * Records that a queued request has been handed to the transport
+     * and starts tracking it for response correlation.
+     *
+     * Subclasses override this to perform the actual transport-level
+     * dispatch, then call back into `super.send(...)` so the in-flight
+     * map stays accurate. Fire-and-forget requests
+     * (`requestId === -1`) and entries with no callback are not
+     * inserted into the map because there is nothing to resolve them
+     * to.
+     */
     send(operationPending: OperationPending): void;
+    /**
+     * Folds a fresh round-trip measurement into the rolling latency
+     * average.
+     *
+     * The SDK reports half of the measured round-trip as transport
+     * latency on the assumption that downstream and upstream legs
+     * have similar duration. The window keeps the most recent 10
+     * samples (older entries are dropped from the head). The averaged
+     * value is multiplied by 1000 because consumers expose it in
+     * milliseconds even though the per-sample input is already in
+     * milliseconds — the multiplication compensates for the half
+     * inside the loop.
+     *
+     * @param value Round-trip duration in milliseconds, as reported
+     *              by {@link OperationPending.getExecuteTimerInMs}.
+     */
     addPing(value: number): void;
 }

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

@@ -1,14 +1,98 @@
 import { OperationEvent } from "./../../entity/OperationEvent";
+/**
+ * Contract for a typed server-pushed event handler.
+ *
+ * The SDK delivers two kinds of incoming traffic over the socket:
+ * - **Responses** to operations the client previously sent.
+ * - **Events** the server pushes spontaneously (friend list change,
+ *   group message arrived, group member roster updated, ...).
+ *
+ * Each event handler implementation declares which `EventCode` it is
+ * interested in via {@link getEventCode}, then receives the matching
+ * raw {@link OperationEvent} through {@link handle}. The handler is
+ * responsible for any further deserialisation — typically through
+ * {@link ConverterService.deserializeObject} into a typed payload
+ * class — and for fanning out to application code (usually via a
+ * static callback slot).
+ *
+ * Registration:
+ * - Decorate the handler class with
+ *   `@IServerEventHandler.registerEvent` to opt into the static
+ *   registry. {@link SocketPeer.initGNSocketObject} instantiates one
+ *   handler per registered class during init.
+ * - Or, instantiate a handler manually and call
+ *   {@link GNNetwork.subscriberServerEventHandler} to add it at
+ *   runtime — useful for handlers built dynamically with custom
+ *   instance state.
+ */
 export interface IServerEventHandler {
+    /**
+     * Returns the {@link EventCode} this handler is responsible for.
+     *
+     * The SDK uses the returned value as the dictionary key inside
+     * the per-event-code dispatch table. Multiple handlers may
+     * return the same value; they are dispatched in registration
+     * order.
+     */
     getEventCode(): string;
+    /**
+     * Handles a single decoded {@link OperationEvent} delivered by
+     * the socket transport.
+     *
+     * Implementations typically:
+     * 1. Deserialise `operationEvent.getParameters()` into a typed
+     *    payload class via
+     *    {@link ConverterService.deserializeObject}.
+     * 2. Forward the typed payload to a static callback slot the
+     *    application registers ahead of time.
+     *
+     * Implementations should treat thrown errors as fatal — the
+     * dispatcher in {@link SocketPeer.onEventHandler} does not
+     * wrap the call in try/catch.
+     */
     handle(operationEvent: OperationEvent): void;
 }
+/**
+ * Registry helpers attached to the {@link IServerEventHandler}
+ * interface as a same-named namespace.
+ *
+ * The registry stores **class constructors** (not instances) so that
+ * {@link SocketPeer.initGNSocketObject} can build one fresh instance
+ * per class on SDK startup. This indirection lets handler classes
+ * carry per-instance state if they wish (e.g. last-seen sequence id,
+ * dedup map) without requiring the application to wire them up.
+ */
 export declare namespace IServerEventHandler {
+    /**
+     * Constructor signature accepted by the registry — anything
+     * `new`-able with arbitrary args that produces a `T`. The
+     * `prototype` field is required by the registry call site.
+     */
     type Constructor<T> = {
         new (...args: any[]): T;
         readonly prototype: T;
     };
+    /**
+     * Returns every constructor currently registered with the
+     * registry. Called once during {@link SocketPeer.initGNSocketObject}.
+     */
     export function getImplementations(): Constructor<IServerEventHandler>[];
+    /**
+     * Class decorator that registers a handler so the SDK
+     * instantiates it automatically.
+     *
+     * @example
+     * ```ts
+     * @IServerEventHandler.registerEvent
+     * export class OnSomethingHandler implements IServerEventHandler {
+     *     public getEventCode(): string { return EventCode.OnSomething; }
+     *     public handle(event: OperationEvent): void { ... }
+     * }
+     * ```
+     *
+     * Returns the constructor as-is so it can still be used as a
+     * value (instantiated, type-checked, etc.).
+     */
     export function registerEvent<T extends Constructor<IServerEventHandler>>(ctor: T): T;
     export {};
 }

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

@@ -2,12 +2,81 @@ import { Action1 } from "./../../common/Action1";
 import { OperationEvent } from "./../../entity/OperationEvent";
 import { GenericModels } from "./../../entity/models/GenericModels";
 import { IServerEventHandler } from "./IServerEventHandler";
+/**
+ * Decoded payload of the `OnCharacterPlayerFriendUpdate` server
+ * event.
+ *
+ * Pushed by the backend whenever the friend roster of an
+ * already-loaded character changes — accept / decline / remove /
+ * incoming-request / status update. The application uses this to
+ * keep the in-game social UI in sync without polling.
+ *
+ * Pair this event with the related operations on
+ * `GNNetwork.characterPlayer` (`acceptCharacterPlayerFriend`,
+ * `removeCharacterPlayerFriend`, ...): when the local player issues
+ * one of those operations the server eventually echoes the resulting
+ * roster back as this event so every connected device converges.
+ */
 export declare class CharacterPlayerFriendUpdate {
+    /**
+     * Identifier of the character whose friend list is being updated.
+     *
+     * Matches the character id the local SDK selected via
+     * `GNNetwork.characterPlayer.selectCharacter*` (or whichever
+     * method created it). When the application has multiple
+     * characters loaded, dispatch on this field to update the right
+     * roster.
+     */
     characterId: string;
+    /**
+     * Authoritative friend roster after the change.
+     *
+     * Each {@link GenericModels.FriendItem} carries the full
+     * relation state ({@link FriendStatus}, friend id, optional
+     * profile data). Treat the array as a complete replacement —
+     * the backend does not send delta updates here.
+     */
     playerFriends: Array<GenericModels.FriendItem>;
 }
+/**
+ * Auto-registered event handler for the
+ * `OnCharacterPlayerFriendUpdate` server event.
+ *
+ * Wiring at startup:
+ * 1. The `@IServerEventHandler.registerEvent` decorator places the
+ *    class into the static registry at module-load time.
+ * 2. {@link SocketPeer.initGNSocketObject} instantiates one handler
+ *    per registered class and indexes them by their event code.
+ * 3. When the matching event arrives the SDK calls {@link handle}
+ *    on this instance, which deserialises the parameters into a
+ *    {@link CharacterPlayerFriendUpdate} and dispatches via the
+ *    application-supplied static callback.
+ *
+ * Application setup:
+ * ```ts
+ * OnCharacterPlayerFriendUpdateEventHandler.onUpdate = update => {
+ *     console.log("friends now", update.playerFriends);
+ * };
+ * ```
+ */
 export declare class OnCharacterPlayerFriendUpdateEventHandler implements IServerEventHandler {
+    /**
+     * Static callback the application registers. The SDK calls it
+     * with the deserialised payload whenever a matching event
+     * arrives. Leave `null` to ignore the event.
+     */
     static onUpdate: Action1<CharacterPlayerFriendUpdate>;
+    /**
+     * Returns {@link EventCode.OnCharacterPlayerFriendUpdate}, the
+     * stable event code emitted by the GearN backend for this
+     * push.
+     */
     getEventCode(): string;
+    /**
+     * Deserialises the raw parameters into a typed
+     * {@link CharacterPlayerFriendUpdate} and forwards it to
+     * {@link onUpdate}. Skipped silently when the application has
+     * not registered a callback.
+     */
     handle(operationEvent: OperationEvent): void;
 }

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

@@ -2,12 +2,61 @@ import { Action1 } from "./../../common/Action1";
 import { OperationEvent } from "./../../entity/OperationEvent";
 import { GenericModels } from "./../../entity/models/GenericModels";
 import { IServerEventHandler } from "./IServerEventHandler";
+/**
+ * Decoded payload of the `OnCharacterPlayerGroupUpdate` server
+ * event.
+ *
+ * Pushed by the backend whenever the group membership of an
+ * already-loaded character changes — invitation, accept, leave,
+ * kick, role change. Use it to refresh the in-game guild / clan UI
+ * without polling.
+ */
 export declare class CharacterPlayerGroupUpdate {
+    /**
+     * Identifier of the character whose group membership changed.
+     * Mirrors the `characterId` selected by the local SDK so a
+     * multi-character host can route the update to the right view.
+     */
     characterId: string;
+    /**
+     * Authoritative group membership list after the change. Each
+     * {@link GenericModels.GroupItem} carries the group id, the
+     * member's role, and any embedded summary fields the backend
+     * chose to include. Treat the array as a complete replacement.
+     */
     playerGroups: Array<GenericModels.GroupItem>;
 }
+/**
+ * Auto-registered event handler for the
+ * `OnCharacterPlayerGroupUpdate` server event.
+ *
+ * Same lifecycle as the rest of the `On*EventHandler` family —
+ * registered at module load via
+ * `@IServerEventHandler.registerEvent`, instantiated once during
+ * {@link SocketPeer.initGNSocketObject}, then invoked on every
+ * incoming event.
+ *
+ * Application setup:
+ * ```ts
+ * OnCharacterPlayerGroupUpdateEventHandler.onUpdate = update => {
+ *     refreshGuildUi(update.playerGroups);
+ * };
+ * ```
+ */
 export declare class OnCharacterPlayerGroupUpdateEventHandler implements IServerEventHandler {
+    /**
+     * Static callback the application registers. Leave `null` to
+     * silently drop the event.
+     */
     static onUpdate: Action1<CharacterPlayerGroupUpdate>;
+    /**
+     * Returns {@link EventCode.OnCharacterPlayerGroupUpdate}.
+     */
     getEventCode(): string;
+    /**
+     * Deserialises the parameters into a
+     * {@link CharacterPlayerGroupUpdate} and forwards to
+     * {@link onUpdate}.
+     */
     handle(operationEvent: OperationEvent): void;
 }

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

@@ -2,12 +2,62 @@ import { Action1 } from "./../../common/Action1";
 import { OperationEvent } from "./../../entity/OperationEvent";
 import { GenericModels } from "./../../entity/models/GenericModels";
 import { IServerEventHandler } from "./IServerEventHandler";
+/**
+ * Decoded payload of the `OnGamePlayerFriendUpdate` server event.
+ *
+ * Pushed by the backend whenever the master-player friend list (the
+ * account-level social graph, distinct from per-character friends)
+ * changes — accept, decline, remove, status update. Use it to keep
+ * the lobby / account-level friend UI in sync without polling.
+ *
+ * Pair with the operations on `GNNetwork.gamePlayer`
+ * (`acceptGamePlayerFriend`, `removeGamePlayerFriend`, etc.):
+ * the server echoes the resulting roster back through this event so
+ * every connected device for the same account converges.
+ */
 export declare class GamePlayerFriendUpdate {
+    /**
+     * Optional character id when the backend scopes the update to
+     * a specific character context (multi-character titles).
+     * Absent for purely account-scoped friend changes.
+     */
     characterId?: string;
+    /**
+     * Authoritative friend roster after the change. Treat as a
+     * complete replacement — the backend does not send deltas.
+     */
     playerFriends: Array<GenericModels.FriendItem>;
 }
+/**
+ * Auto-registered event handler for the
+ * `OnGamePlayerFriendUpdate` server event.
+ *
+ * Same lifecycle as the rest of the `On*EventHandler` family —
+ * registered through `@IServerEventHandler.registerEvent`,
+ * instantiated by {@link SocketPeer.initGNSocketObject}, then
+ * invoked on every matching event.
+ *
+ * Application setup:
+ * ```ts
+ * OnGamePlayerFriendUpdateEventHandler.onUpdate = update => {
+ *     refreshLobbyFriendsUi(update.playerFriends);
+ * };
+ * ```
+ */
 export declare class OnGamePlayerFriendUpdateEventHandler implements IServerEventHandler {
+    /**
+     * Static callback the application registers. Leave `null` to
+     * silently drop the event.
+     */
     static onUpdate: Action1<GamePlayerFriendUpdate>;
+    /**
+     * Returns {@link EventCode.OnGamePlayerFriendUpdate}.
+     */
     getEventCode(): string;
+    /**
+     * Deserialises the parameters into a
+     * {@link GamePlayerFriendUpdate} and forwards to
+     * {@link onUpdate}.
+     */
     handle(operationEvent: OperationEvent): void;
 }

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

@@ -2,12 +2,53 @@ import { Action1 } from "./../../common/Action1";
 import { OperationEvent } from "./../../entity/OperationEvent";
 import { GenericModels } from "./../../entity/models/GenericModels";
 import { IServerEventHandler } from "./IServerEventHandler";
+/**
+ * Decoded payload of the `OnGamePlayerGroupUpdate` server event.
+ *
+ * Pushed by the backend whenever the master-player group membership
+ * changes — invitation, accept, leave, kick, role change. The
+ * account-level analogue of
+ * {@link CharacterPlayerGroupUpdate}; use it to refresh
+ * lobby / account-level group UI without polling.
+ */
 export declare class GamePlayerGroupUpdate {
+    /**
+     * Optional character id when the backend scopes the update to
+     * a specific character context. Absent for purely
+     * account-scoped group changes.
+     */
     characterId?: string;
+    /**
+     * Authoritative group membership list after the change. Treat
+     * as a complete replacement.
+     */
     playerGroups: Array<GenericModels.GroupItem>;
 }
+/**
+ * Auto-registered event handler for the
+ * `OnGamePlayerGroupUpdate` server event.
+ *
+ * Application setup:
+ * ```ts
+ * OnGamePlayerGroupUpdateEventHandler.onUpdate = update => {
+ *     refreshLobbyGroupsUi(update.playerGroups);
+ * };
+ * ```
+ */
 export declare class OnGamePlayerGroupUpdateEventHandler implements IServerEventHandler {
+    /**
+     * Static callback the application registers. Leave `null` to
+     * silently drop the event.
+     */
     static onUpdate: Action1<GamePlayerGroupUpdate>;
+    /**
+     * Returns {@link EventCode.OnGamePlayerGroupUpdate}.
+     */
     getEventCode(): string;
+    /**
+     * Deserialises the parameters into a
+     * {@link GamePlayerGroupUpdate} and forwards to
+     * {@link onUpdate}.
+     */
     handle(operationEvent: OperationEvent): void;
 }

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

@@ -2,11 +2,58 @@ import { Action1 } from "./../../common/Action1";
 import { OperationEvent } from "./../../entity/OperationEvent";
 import { GenericModels } from "./../../entity/models/GenericModels";
 import { IServerEventHandler } from "./IServerEventHandler";
+/**
+ * Decoded payload of the `OnGroupMemberUpdate` server event.
+ *
+ * Pushed by the backend whenever the member roster of a group
+ * changes — join, leave, role change, kick. Every device currently
+ * subscribed to that group receives the same payload so all clients
+ * converge on the same view of the roster.
+ *
+ * Pair with the operations on `GNNetwork.group` (`acceptGroupMember`,
+ * `removeGroupMember`, `setGroupMemberRole`, ...): after one client
+ * issues such an operation the server fans the resulting roster out
+ * through this event.
+ */
 export declare class GroupMemberUpdate {
+    /**
+     * Authoritative member roster after the change. Each
+     * {@link GenericModels.MemberItem} carries the user id, role,
+     * join timestamp and optional profile metadata. Treat the
+     * array as a complete replacement.
+     */
     members: Array<GenericModels.MemberItem>;
+    /**
+     * Identifier of the group whose member roster changed. Use
+     * this to route the update to the correct group view when the
+     * application has multiple groups loaded.
+     */
+    groupId: string;
 }
+/**
+ * Auto-registered event handler for the `OnGroupMemberUpdate`
+ * server event.
+ *
+ * Application setup:
+ * ```ts
+ * OnGroupMemberUpdateEventHandler.onUpdate = update => {
+ *     refreshGroupMembersUi(update.groupId, update.members);
+ * };
+ * ```
+ */
 export declare class OnGroupMemberUpdateEventHandler implements IServerEventHandler {
+    /**
+     * Static callback the application registers. Leave `null` to
+     * silently drop the event.
+     */
     static onUpdate: Action1<GroupMemberUpdate>;
+    /**
+     * Returns {@link EventCode.OnGroupMemberUpdate}.
+     */
     getEventCode(): string;
+    /**
+     * Deserialises the parameters into a {@link GroupMemberUpdate}
+     * and forwards to {@link onUpdate}.
+     */
     handle(operationEvent: OperationEvent): void;
 }