@xmobitea/gn-typescript-client 2.6.13 → 2.6.14

package/dist/runtime/entity/request/CustomOperationRequest.d.ts

@@ -2,19 +2,118 @@ import { Constructor } from "./../GNMetadata";
 import { RequestRole } from "./../../constant/enumType/RequestRole";
 import { RequestType } from "./../../constant/enumType/RequestType";
 import { OperationRequest } from "./../OperationRequest";
+/**
+ * Abstract base of every typed request wrapper exported by the SDK.
+ *
+ * Every generated `*OperationRequest` class
+ * (`AuthenticateRequestModels.LoginByAccountOperationRequest`,
+ * `GroupRequestModels.GetGroupListOperationRequest`, ...) extends
+ * either this class directly or its DTO-shaped subclass
+ * {@link CustomOperationRequestAbstract}. The role of the wrapper
+ * is to bind a typed request DTO to the three pieces of routing
+ * metadata the transport needs:
+ * - the {@link OperationCode} string;
+ * - the {@link RequestType} group;
+ * - the {@link RequestRole} (Client / Server / Admin) the backend
+ *   should evaluate the auth token against.
+ *
+ * Subclasses fill those three protected fields in their declaration
+ * (`protected override operationCode = ...`, etc.) and implement
+ * {@link build} so the helper machinery in
+ * {@link GNNetwork.sendViaSocketTRequestTResponse} can produce a
+ * raw {@link OperationRequest} for the transport.
+ */
 export declare abstract class CustomOperationRequest {
+    /** Operation code from {@link OperationCode}. */
     protected abstract operationCode: string;
+    /** Request type discriminator (logical category). */
     protected abstract requestType: RequestType;
+    /** Permission scope evaluated against the auth token by the backend. */
     protected abstract role: RequestRole;
+    /**
+     * Per-request timeout in **seconds**, captured at construction
+     * time and forwarded into the underlying
+     * {@link OperationRequest} by {@link build}.
+     */
     protected operationTimeout: number;
+    /**
+     * Returns the request type the transport should encode into the
+     * outbound frame.
+     */
     getRequestType(): RequestType;
+    /**
+     * Returns the permission scope the backend should evaluate
+     * against the active auth token.
+     *
+     * Used by {@link GNNetwork.sendViaSocketTRequestTResponse} /
+     * `sendViaHttpTRequestTResponse` when they translate the typed
+     * wrapper into a raw {@link OperationRequest}.
+     */
     getRole(): RequestRole;
+    /**
+     * @param timeout Per-request timeout in seconds. Pass
+     *                {@link OperationRequest.defaultTimeOut} to opt
+     *                into the transport's configured default.
+     */
     constructor(timeout: number);
+    /**
+     * Materialises the typed wrapper into a low-level
+     * {@link OperationRequest} ready for the transport layer.
+     *
+     * The default implementation in
+     * {@link CustomOperationRequestAbstract} is enough for every
+     * generated wrapper; subclasses only need to override `build`
+     * when they encode parameters in a non-DTO shape (e.g. a
+     * placeholder request with no body).
+     */
     abstract build(): OperationRequest;
 }
+/**
+ * DTO-aware base used by every generated request wrapper.
+ *
+ * Stores the typed request DTO and its class reference so
+ * {@link build} can hand both to
+ * {@link ConverterService.serializeObject} for wire-format
+ * conversion. Subclasses just declare the three protected fields
+ * (`operationCode`, `requestType`, `role`) and pass `this.requestDataCls`
+ * in their constructor.
+ *
+ * @template TRequestData Concrete DTO class that holds the typed
+ *                        parameters for the operation. Must use
+ *                        the GearN `@*DataMember` decorator family
+ *                        so `ConverterService` can serialize it.
+ */
 export declare abstract class CustomOperationRequestAbstract<TRequestData> extends CustomOperationRequest {
+    /**
+     * Public so application code can inspect / mutate the DTO
+     * before issuing the request (e.g. patching a single field
+     * rather than re-building the wrapper).
+     */
     requestData: TRequestData;
+    /**
+     * Reference to the DTO class. Required by
+     * {@link ConverterService.serializeObject} to look up the
+     * cached field metadata produced by the decorators.
+     */
     protected requestDataCls: Constructor<TRequestData>;
+    /**
+     * @param requestData Typed parameter DTO instance to send.
+     * @param timeout     Per-request timeout in seconds.
+     */
     constructor(requestData: TRequestData, timeout: number);
+    /**
+     * Builds the raw {@link OperationRequest} sent to the transport.
+     *
+     * Steps:
+     * 1. Create a fresh `OperationRequest` with the wrapper's
+     *    operation code and timeout.
+     * 2. Serialise the DTO through
+     *    {@link ConverterService.serializeObject} and attach the
+     *    resulting {@link GNHashtable} as the request parameters.
+     *
+     * The request id stays unassigned at this point — it will be
+     * filled by {@link PeerBase.enqueue} when the request is
+     * queued.
+     */
     build(): OperationRequest;
 }

package/dist/runtime/entity/response/CustomOperationResponse.d.ts

@@ -2,19 +2,137 @@ import { Constructor } from "./../GNMetadata";
 import { GNHashtable } from "./../../common/GNData";
 import { InvalidMember } from "./../InvalidMember";
 import { OperationResponse } from "./../OperationResponse";
+/**
+ * Abstract base of every typed response wrapper exposed by the SDK.
+ *
+ * Each generated `*OperationResponse` class extends either this
+ * class or its DTO-shaped subclass
+ * {@link CustomOperationResponseAbstract}. The role of the wrapper
+ * is to (a) capture the low-level
+ * {@link OperationResponse} fields onto strongly typed properties
+ * the application can read directly, and (b) decode the
+ * domain-level {@link ErrorCode} carried inside the parameter bag
+ * so success-with-business-error responses are distinguishable
+ * from transport failures.
+ *
+ * Two-tier error model:
+ * - {@link returnCode} reflects the transport-level
+ *   {@link ReturnCode} — anything other than `Ok` is a transport,
+ *   timeout or validation failure. Use {@link hasReturnCodeError}
+ *   for the boolean check.
+ * - {@link errorCode} carries the domain-level {@link ErrorCode}
+ *   that the backend writes into a successful response payload to
+ *   describe business outcomes. Only populated when the response
+ *   has no return-code error.
+ *
+ * Application code typically inspects both:
+ * ```ts
+ * if (response.hasReturnCodeError()) {
+ *     // transport / validation failure
+ *     return showError(response.debugMessage);
+ * }
+ * if (response.errorCode !== ErrorCode.Ok) {
+ *     // domain failure
+ *     return showError(response.errorCode);
+ * }
+ * // success: read response.responseData
+ * ```
+ */
 export declare abstract class CustomOperationResponse {
+    /** Operation code mirrored from the matching request. */
     operationCode: string;
+    /** Raw response parameter bag; usually consumed indirectly through the typed `responseData`. */
     parameters: GNHashtable;
+    /** Transport-level return code (from {@link ReturnCode}). */
     returnCode: number;
+    /** Backend-supplied debug message; populated mostly for failures. */
     debugMessage: string;
+    /**
+     * Domain-level error code (from {@link ErrorCode}). Populated
+     * only when {@link returnCode} is `Ok`. Read this **after**
+     * {@link hasReturnCodeError} confirms transport success.
+     */
     errorCode: number;
+    /**
+     * Validation failure entries, populated when
+     * {@link returnCode} equals
+     * `ReturnCode.InvalidRequestParameters`.
+     */
     invalidMembers: InvalidMember[];
+    /**
+     * Returns whether the transport-level return code indicates a
+     * failure (anything other than `Ok`).
+     *
+     * Note: this does **not** consider {@link errorCode} — a
+     * transport-successful response may still carry a domain
+     * failure, which the caller has to check separately by
+     * comparing `errorCode` to the relevant {@link ErrorCode}
+     * constants.
+     */
     hasReturnCodeError(): boolean;
+    /**
+     * Copies the low-level {@link OperationResponse} fields into
+     * the typed wrapper.
+     *
+     * Called by the SDK helpers
+     * {@link GNNetwork.sendViaSocketTResponse} /
+     * `sendViaHttpTResponse` after they receive the raw response
+     * from the transport. Subclasses such as
+     * {@link CustomOperationResponseAbstract} chain into this
+     * implementation and then run their own DTO deserialisation.
+     *
+     * Side effect: when the response is transport-successful, this
+     * method also reads `ParameterCode.ErrorCode` out of the
+     * parameters and stores it on {@link errorCode} so call sites
+     * can check the domain outcome without re-touching the
+     * parameter bag.
+     */
     setupOperationResponse(operationResponse: OperationResponse): void;
+    /**
+     * Returns a compact string useful for logging.
+     *
+     * Format: `"ReturnCode: <code> <parameters | debugMessage>"`.
+     * Parameters are stringified through
+     * {@link GNHashtable.toString} when available, otherwise the
+     * raw debug message takes their place.
+     */
     toString(): string;
 }
+/**
+ * DTO-aware base used by every generated response wrapper.
+ *
+ * Subclasses populate `responseDataCls` in their constructor /
+ * declaration so that {@link setupOperationResponse} can
+ * automatically deserialise the parameter bag into a strongly
+ * typed payload after a transport-successful response.
+ *
+ * @template TResponseData Concrete response DTO class. Must use
+ *                         the GearN `@*DataMember` decorator
+ *                         family so {@link ConverterService} can
+ *                         resolve the field metadata.
+ */
 export declare abstract class CustomOperationResponseAbstract<TResponseData> extends CustomOperationResponse {
+    /**
+     * Typed response payload deserialised from
+     * {@link parameters}. Stays `undefined` when the response
+     * carried a transport error.
+     */
     responseData: TResponseData;
+    /**
+     * Reference to the DTO class. Required by
+     * {@link ConverterService.deserializeObject} to resolve
+     * decorator-driven field metadata.
+     */
     protected responseDataCls: Constructor<TResponseData>;
+    /**
+     * Chains into {@link CustomOperationResponse.setupOperationResponse}
+     * and additionally deserialises the parameters into
+     * {@link responseData} when the response has no transport
+     * error.
+     *
+     * Skipped on transport failure: the caller must inspect
+     * {@link hasReturnCodeError} / {@link debugMessage} /
+     * {@link invalidMembers} instead.
+     */
     setupOperationResponse(operationResponse: OperationResponse): void;
 }

package/dist/runtime/entity/response/GetAuthInfoResponse.d.ts

@@ -1,15 +1,68 @@
 import { GNHashtable } from "./../../common/GNData";
+/**
+ * Decoded shape of the `getAuthInfo` HTTP endpoint payload.
+ *
+ * Populated only when the endpoint returned a `200` response with a
+ * non-error envelope (`{ data: ..., error: null }`). The fields
+ * mirror the columns the GearN backend stores for an issued auth
+ * token.
+ */
 interface AuthInfoResponse {
+    /**
+     * The raw GearN auth token the SDK normally caches in
+     * {@link AuthenticateStatus}. Returned here so admin tooling
+     * can confirm which exact token the backend resolved.
+     */
     gnToken: string;
+    /** User id this token is bound to. */
     userId: string;
+    /**
+     * Whether the token was logically removed (revoked by the
+     * backend, e.g. after a forced logout). When `true` the token
+     * is no longer valid for any operation.
+     */
     isRemove: boolean;
+    /**
+     * Absolute expiration timestamp in milliseconds since epoch.
+     * The SDK does not refresh the token automatically; the
+     * application is expected to call
+     * `GNNetwork.authenticate.refreshAuthToken` before this
+     * deadline.
+     */
     tsExpire: number;
+    /**
+     * Custom provider data captured at login time
+     * (`LoginByGenericService` and friends). Re-shaped from the
+     * raw JSON object into a {@link GNHashtable} by
+     * {@link NetworkingPeer.getAuthInfo} so callers can use the
+     * typed accessors.
+     */
     otherDatas: GNHashtable;
+    /** Issue timestamp in milliseconds since epoch. */
     tsCreate: number;
+    /** Secret key bound to the token (admin context only). */
     secretKey: string;
 }
+/**
+ * Top-level wrapper returned by
+ * {@link GNNetwork.getAuthInfo} / `getAuthInfoAsync`.
+ *
+ * The wrapper always carries either an `error` string or a `data`
+ * payload, never both. Application code typically inspects `error`
+ * first and falls back to `data` once the error path is ruled out.
+ */
 export declare class GetAuthInfoResponse {
+    /**
+     * Transport-level error message returned by the backend, or
+     * `null` when the call succeeded. The SDK populates this on
+     * non-200 responses, JSON parse failures, and any captured
+     * Axios exception.
+     */
     error: string;
+    /**
+     * Decoded auth-info payload. Defined only when {@link error}
+     * is `null`.
+     */
     data?: AuthInfoResponse;
 }
 export {};

package/dist/runtime/entity/response/HealthCheckResponse.d.ts

@@ -1,21 +1,77 @@
+/**
+ * Per-instance status block returned by the GearN health-check
+ * endpoint.
+ *
+ * The backend runs in clusters where one node is the **primary**
+ * (acts as the source of truth for clock / leader election) and
+ * the rest are **replicas**. The fields below describe one node's
+ * view of the cluster topology at the moment of the health check.
+ */
 interface InstanceResponse {
+    /** Identifier of the node returning this block. */
     instanceId: string;
+    /**
+     * Whether the node is currently the cluster primary. Only one
+     * node should report `true` at any given time; multiple
+     * primaries indicate a split-brain situation.
+     */
     isPrimary: boolean;
+    /** Identifier of the node currently considered primary. */
     currentInstanceIdPrimary: string;
+    /** Primary clock value at the time of the check (ms since epoch). */
     currentTsPrimary: number;
+    /** Same as `currentTsPrimary` formatted as a human-readable date. */
     currentTsPrimaryToDate: string;
+    /** Last primary timestamp this node observed (ms since epoch). */
     tsPrimary: number;
+    /** Same as `tsPrimary` formatted as a human-readable date. */
     tsPrimaryToDate: string;
 }
+/**
+ * Per-replica view returned alongside the primary block.
+ *
+ * Extends {@link InstanceResponse} with the additional `lostPing`
+ * counter so operators can spot replicas that have fallen behind on
+ * the primary's heartbeat.
+ */
 interface OtherInstanceResponse extends InstanceResponse {
+    /**
+     * Number of consecutive missed heartbeats the primary
+     * observed for this replica. A non-zero value typically
+     * indicates the replica is degraded.
+     */
     lostPing: number;
 }
+/**
+ * Decoded shape of the `healthcheck` HTTP endpoint payload.
+ *
+ * Populated only when the endpoint returned a `200` response with a
+ * non-error envelope.
+ */
 interface HealthCheckDataResponse {
+    /** Status block of the node that handled the request. */
     thisInstance: InstanceResponse;
+    /** Status of every other node the primary tracks. */
     otherInstances: OtherInstanceResponse[];
 }
+/**
+ * Top-level wrapper returned by
+ * {@link GNNetwork.healthCheck} / `healthCheckAsync`.
+ *
+ * The wrapper always carries either an `error` string or a `data`
+ * payload, never both. Useful for warm-up probes or readiness
+ * dashboards — the endpoint does not require an auth token.
+ */
 export declare class HealthCheckResponse {
+    /**
+     * Transport-level error message, or `null` when the call
+     * succeeded.
+     */
     error: string;
+    /**
+     * Decoded health-check payload. Defined only when
+     * {@link error} is `null`.
+     */
     data?: HealthCheckDataResponse;
 }
 export {};

package/dist/runtime/entity/response/UploadFileResponse.d.ts

@@ -1,3 +1,22 @@
+/**
+ * Wrapper returned by {@link GNNetwork.uploadFile} /
+ * `uploadFileAsync`.
+ *
+ * The upload endpoint does not return a structured payload — a
+ * `200` response with an empty body is enough to confirm the upload
+ * was committed. The SDK therefore exposes a single `error` field
+ * which is `null` on success and a captured error message on
+ * failure (auth missing, transport error, non-200 status). The
+ * application consumes the response with a simple
+ * `if (response.error) { ... }` check.
+ */
 export declare class UploadFileResponse {
+    /**
+     * Transport / authentication error captured by the SDK, or
+     * `null` when the upload succeeded. Common values:
+     * `"Auth token null"` (the cached token was empty),
+     * `"Unknown Error"` (non-200 status with no captured detail),
+     * or any Axios-thrown error message.
+     */
     error: string;
 }

package/dist/runtime/helper/CodeHelper.d.ts

@@ -1,15 +1,137 @@
+/**
+ * Static facade for converting GearN numeric codes into the
+ * lowercase-first-letter display names the backend expects on the
+ * wire (and that look familiar in log lines).
+ *
+ * Categories:
+ * - `getReturnCodeName(returnCode)` — translates the
+ *   {@link ReturnCode} value carried by every response.
+ * - `getRequestTypeName(requestType)` — translates the
+ *   {@link RequestType} enum to the camelCase string used in
+ *   {@link OperationHelper.toSocketData} and the HTTP URL.
+ * - `getRequestRoleName(requestRole)` — translates the
+ *   {@link RequestRole} enum the same way.
+ * - `getInvalidMemberName(invalidMember)` — translates the
+ *   {@link InvalidMemberType} enum used in
+ *   {@link OperationResponse.getInvalidMembers}.
+ *
+ * Lifecycle: {@link init} runs from {@link GNNetwork.init} before
+ * any model serialisation happens. After init, the lookups are
+ * effectively immutable; the SDK does not expose a teardown.
+ *
+ * Extensibility: each category exposes an `add*Dic` method so
+ * downstream applications can extend the lookup table with their
+ * own enum values without forking the SDK. This is mostly used by
+ * white-label deployments that introduce custom return codes.
+ */
 export declare class CodeHelper {
+    /** Helper backing {@link getReturnCodeName}. */
     private static returnCodeHelper;
+    /** Helper backing {@link getRequestTypeName}. */
     private static requestTypeHelper;
+    /** Helper backing {@link getRequestRoleName}. */
     private static requestRoleHelper;
+    /** Helper backing {@link getInvalidMemberName}. */
+    private static invalidMemberHelper;
+    /**
+     * Returns the display name for a backend return code (e.g.
+     * `ReturnCode.Ok` → `"Ok"`).
+     */
     static getReturnCodeName(returnCode: number): string;
+    /**
+     * Returns the display name for a request-type code (e.g.
+     * `RequestType.Authenticate` → `"authenticate"`).
+     *
+     * The lowercased-first-letter convention matches the URL
+     * segment the backend expects for the HTTP API, and the
+     * matching index 0 in the socket frame produced by
+     * {@link OperationHelper.toSocketData}.
+     */
     static getRequestTypeName(requestType: number): string;
+    /**
+     * Returns the display name for a request-role code (e.g.
+     * `RequestRole.Client` → `"client"`).
+     */
     static getRequestRoleName(requestRole: number): string;
+    /**
+     * Returns the display name for an
+     * {@link InvalidMemberType} value used by the validation
+     * machinery on the response side.
+     *
+     * @param invalidMember Numeric value picked from the response
+     *                      `invalidRequestParameters` array entry.
+     * @returns The display name, or `"Unknown (<n>)"` when the
+     *          value is not registered.
+     */
+    static getInvalidMemberName(invalidMember: number): string;
+    /**
+     * Builds every lookup table.
+     *
+     * Called once from {@link GNNetwork.init} before any operation
+     * is sent. Subsequent invocations rebuild every helper from
+     * scratch — useful in test setups that reset the SDK between
+     * cases.
+     */
     static init(): void;
+    /**
+     * Resets the return-code helper to a fresh instance and seeds
+     * it from the canonical {@link ReturnCode} enum.
+     */
     private static setReturnCodeDic;
+    /**
+     * Adds entries from any enum-shaped object into the
+     * return-code helper without lowercasing the first letter.
+     *
+     * Used by white-label deployments that ship additional return
+     * codes — they call this method once after
+     * {@link GNNetwork.init} with their own enum.
+     *
+     * @param returnCode Enum-shaped object whose entries should be
+     *                   merged into the helper.
+     */
     static addReturnCodeDic(returnCode: any): void;
+    /**
+     * Resets the request-type helper to a fresh instance and seeds
+     * it from the canonical {@link RequestType} enum.
+     */
     private static setRequestTypeDic;
+    /**
+     * Adds entries from any enum-shaped object into the
+     * request-type helper, lowercasing the first letter so the
+     * stored value matches the wire format
+     * (`RequestType.Authenticate` → `"authenticate"`).
+     *
+     * @param requestType Enum-shaped object whose entries should
+     *                    be merged into the helper.
+     */
     static addRequestTypeDic(requestType: any): void;
+    /**
+     * Resets the request-role helper to a fresh instance and seeds
+     * it from the canonical {@link RequestRole} enum.
+     */
     private static setRequestRoleDic;
+    /**
+     * Adds entries from any enum-shaped object into the
+     * request-role helper, lowercasing the first letter the same
+     * way {@link addRequestTypeDic} does.
+     *
+     * @param requestRole Enum-shaped object whose entries should
+     *                    be merged into the helper.
+     */
     static addRequestRoleDic(requestRole: any): void;
+    /**
+     * Resets the invalid-member helper to a fresh instance and
+     * seeds it from the canonical {@link InvalidMemberType} enum.
+     */
+    private static setInvalidMemberDic;
+    /**
+     * Adds entries from any enum-shaped object into the
+     * invalid-member helper, lowercasing the first letter so the
+     * stored value matches the human-readable form used in
+     * validation log lines.
+     *
+     * @param invalidMember Enum-shaped object whose entries should
+     *                      be merged into the helper.
+     */
+    static addInvalidMemberDic(invalidMember: any): void;
 }

package/dist/runtime/helper/ConverterService.d.ts

@@ -1,14 +1,88 @@
 import { GNArray, GNHashtable } from "./../common/GNData";
+/**
+ * Local alias for an instantiable class.
+ *
+ * Re-declared here (rather than imported from
+ * {@link entity/GNMetadata}) so this file does not have to depend
+ * on the metadata module just for the alias — the underlying shape
+ * is identical.
+ */
 type Constructor<T> = {
     new (...args: any[]): T;
 };
+/**
+ * Static facade for the SDK's typed model (de)serialisation.
+ *
+ * Most application code does not need to touch this directly — the
+ * generated `*Api` wrappers and request/response models call into
+ * it internally after {@link GNNetwork.init} runs
+ * {@link ConverterService.init}. Reach for this class manually
+ * only for advanced workflows: custom DTOs, unit tests that round
+ * trip a model through the SDK encoder, or hand-built operation
+ * requests that produce non-standard response shapes.
+ *
+ * Lifecycle:
+ * - {@link init} runs from {@link GNNetwork.init} and allocates
+ *   one shared {@link DataMemberFieldInfoTypeMapper} that backs
+ *   both the serializer and the deserializer (so the metadata
+ *   cache is shared between the two directions).
+ * - There is no `dispose()`; the singleton lives for the lifetime
+ *   of the JS realm.
+ */
 export declare class ConverterService {
     private static serializeConverter;
     private static deserializeConverter;
+    /**
+     * Deserialises a {@link GNHashtable} into a typed model
+     * instance.
+     *
+     * The class supplied as `cls` must use the GearN
+     * `@*DataMember` decorator family so the SDK can resolve the
+     * field-code mapping. Classes without decorators yield an
+     * instance with no fields populated.
+     *
+     * @param gnHashtable Source container; usually obtained from
+     *                    `OperationResponse.getParameters()`.
+     * @param cls         Target model class.
+     * @returns           Populated `T` instance, or `null` when
+     *                    `gnHashtable` is `null`.
+     */
     static deserializeObject<T>(gnHashtable: GNHashtable, cls: Constructor<T>): any;
+    /**
+     * Deserialises a {@link GNArray} into an array of typed model
+     * instances or primitives.
+     *
+     * For arrays of custom objects, `cls` should be the element
+     * class decorated with the GearN metadata. For arrays of
+     * primitives pass the matching wrapper (`String`, `Number`,
+     * `Boolean`).
+     */
     static deserializeArray<T>(gnArray: GNArray, cls: Constructor<T>): any[];
+    /**
+     * Serialises a typed model instance into a {@link GNHashtable}
+     * suitable for the wire.
+     *
+     * The result is the same shape that the request build pipeline
+     * inside `*OperationRequest.build()` produces — pass it to
+     * `OperationRequest.setParameters` if you are constructing a
+     * raw request manually.
+     */
     static serializeObject<T>(obj: any, cls: Constructor<T>): GNHashtable;
+    /**
+     * Serialises an array of typed model instances or primitives
+     * into a {@link GNArray}.
+     *
+     * For arrays of custom objects, `cls` should be the element
+     * class decorated with GearN metadata.
+     */
     static serializeArray<T>(objLst: [], cls: Constructor<T>): GNArray;
+    /**
+     * Allocates the shared serializer / deserializer singletons.
+     *
+     * Run once from {@link GNNetwork.init}. Calling it again
+     * rebuilds the singletons from scratch, which is convenient in
+     * test setups that need to reset the SDK between cases.
+     */
     static init(): void;
 }
 export {};