@calimero-network/mero-js 26.10.0 → 27.0.0

package/dist/events/sse.d.ts

@@ -1,127 +0,0 @@
-import type { GroupMembershipEventData, GroupMigrationEventData } from './group.js';
-/** How long a subscription POST may take before it counts as failed. */
-export declare const SUBSCRIPTION_TIMEOUT_MS = 10000;
-export type { GroupMembershipEventData, GroupMigrationEventData };
-export interface SseEventData {
-    contextId: string;
-    /** The context-event discriminator (core serializes it as a sibling of
-     * `data`, e.g. `"AppVersionChanged"`). Undefined for events without a tag. */
-    type?: string;
-    data: unknown;
-}
-/** Parsed `AppVersionChanged` context event (bundle-version flip; skew #2). */
-export interface AppVersionChangedEvent {
-    contextId: string;
-    fromVersion?: string;
-    toVersion?: string;
-}
-/** Anything the `'event'` stream can deliver: context events plus the
- * group-keyed membership and migration families. */
-type SseEvent = SseEventData | GroupMembershipEventData | GroupMigrationEventData;
-type SseEventHandler = (event: SseEvent) => void;
-type SseConnectHandler = (sessionId: string) => void;
-type SseErrorHandler = (error: Error) => void;
-/**
- * How one request to the SSE endpoints is authenticated.
- *
- * A bearer token is one value reused across requests; a request proof commits to
- * the method, the path and the body, so it must be produced per request. Both
- * reduce to the same thing from this client's point of view — headers — so the
- * stream takes the general form and {@link SseClient} adapts `getAuthToken` to it.
- */
-export type SseAuthorizer = (request: {
-    method: string;
-    path: string;
-    body?: string;
-}) => Promise<Record<string, string>>;
-export declare class SseClient {
-    private baseUrl;
-    private authorize;
-    private reconnectDelayMs;
-    private sessionId;
-    private abortController;
-    private reconnectTimer;
-    private subscribedContextIds;
-    private subscribedGroupIds;
-    /**
-     * The current presence of each subscribed context, as the node's replay and
-     * its live deltas left it: author → that author's last `Ephemeral` data and
-     * when it arrived. The node replays a context's presence once, when the
-     * context is first subscribed on this connection, so a presence listener
-     * that comes later would never see it; {@link presenceSeed} gives it this.
-     */
-    private presence;
-    private closed;
-    private listeners;
-    private fetchImpl;
-    constructor(opts: {
-        baseUrl: string;
-        /** A bearer token provider. The historical form, and still the default. */
-        getAuthToken?: () => Promise<string>;
-        /**
-         * Per-request authorization, for a credential that commits to the request —
-         * a device cert signing a request proof. Takes precedence over
-         * `getAuthToken`; one of the two is required.
-         */
-        authorize?: SseAuthorizer;
-        reconnectDelayMs?: number;
-        fetch?: typeof fetch;
-    });
-    on(event: 'connect', handler: SseConnectHandler): void;
-    on(event: 'event', handler: SseEventHandler): void;
-    on(event: 'error', handler: SseErrorHandler): void;
-    off(event: 'connect', handler: SseConnectHandler): void;
-    off(event: 'event', handler: SseEventHandler): void;
-    off(event: 'error', handler: SseErrorHandler): void;
-    /**
-     * Typed convenience over the generic `'event'` stream: invokes `handler` only
-     * for `AppVersionChanged` context events, with the payload already parsed.
-     * Returns an unsubscribe closure (so callers need not retain the listener).
-     */
-    onAppVersionChanged(handler: (e: AppVersionChangedEvent) => void): () => void;
-    /**
-     * Typed convenience over the generic `'event'` stream: invokes `handler` only
-     * for group-migration events, narrowed on `type` so `data` is the matching
-     * payload. Returns an unsubscribe closure.
-     *
-     * A non-admin subscriber sees `MigrationStarted`, `MigrationProgress` and
-     * `MigrationCompleted` but never `CascadeProgress`, which core delivers to
-     * namespace admins only.
-     */
-    onMigrationEvent(handler: (e: GroupMigrationEventData) => void): () => void;
-    private emit;
-    connect(): Promise<void>;
-    /**
-     * Whether `controller`'s connection is no longer the one this client holds:
-     * closed, or replaced by a later connect. Its abort lands asynchronously,
-     * after a `close()` + `connect()` has already cleared `closed`, so `closed`
-     * alone cannot tell; reporting it, and reconnecting for it, would abort the
-     * live connection, whose own abort would do the same, without end.
-     */
-    private superseded;
-    private readStream;
-    private handleMessage;
-    subscribe(idsOrOpts: string[] | {
-        contextIds?: string[];
-        groupIds?: string[];
-    }): Promise<void>;
-    /** Whether this connection holds `contextId`'s events. */
-    isSubscribed(contextId: string): boolean;
-    /**
-     * The presence currently known for `contextId`, as `Ephemeral` event data,
-     * each entry's `ageMs` advanced by how long ago it arrived. Empty for a
-     * context this connection does not hold.
-     */
-    presenceSeed(contextId: string): Array<Record<string, unknown>>;
-    private notePresence;
-    unsubscribe(idsOrOpts: string[] | {
-        contextIds?: string[];
-        groupIds?: string[];
-    }): Promise<void>;
-    private sendSubscription;
-    /** Sends one subscription change and returns why it failed, or `null`. */
-    private postSubscription;
-    private forceReconnect;
-    private scheduleReconnect;
-    close(): void;
-}

package/dist/events/sse.js

@@ -1,469 +0,0 @@
-import { isGroupMigrationEvent } from './group.js';
-import { AuthRevokedError, HTTPError } from '../http-client/index.js';
-import { carriesProof, refuseProofRedirect } from '../http-client/web-client.js';
-import { signedPath } from '../request-proof/authorizer.js';
-/**
- * `x-auth-error` reasons that mean the whole token family is gone, mirroring
- * the request path in `web-client.ts`. Anything else — `token_expired` above
- * all — is recoverable by refreshing and reconnecting.
- */
-const TERMINAL_AUTH_ERRORS = new Set(['token_reuse', 'token_revoked']);
-/**
- * Statuses a terminal `x-auth-error` can arrive on.
- *
- * Measured against merod 0.11.0-rc.41: a revoked token family answers
- * `GET /sse` and `POST /sse/subscription` with **403**, `x-auth-error:
- * token_revoked` and `content-length: 0` — `token_expired` is the 401.
- * Keying the check on 401 alone made the branch below unreachable for the one
- * reason a stream actually sees, so a dead token family surfaced as a bare
- * `HTTPError(403)` and reconnected on a timer forever.
- */
-const TERMINAL_AUTH_STATUSES = new Set([401, 403]);
-/** How long a subscription POST may take before it counts as failed. */
-export const SUBSCRIPTION_TIMEOUT_MS = 10000;
-/**
- * Whether a failed response means the whole token family is gone, so the caller
- * must re-authenticate and the client must stop reconnecting.
- *
- * The body carries nothing on this path (`content-length: 0`), so the header is
- * the only evidence there is.
- */
-function isTerminalAuthFailure(response) {
-    const authError = response.headers.get('x-auth-error');
-    if (!authError)
-        return null;
-    if (!TERMINAL_AUTH_STATUSES.has(response.status))
-        return null;
-    return TERMINAL_AUTH_ERRORS.has(authError) ? authError : null;
-}
-export class SseClient {
-    constructor(opts) {
-        this.sessionId = null;
-        this.abortController = null;
-        this.reconnectTimer = null;
-        this.subscribedContextIds = new Set();
-        this.subscribedGroupIds = new Set();
-        /**
-         * The current presence of each subscribed context, as the node's replay and
-         * its live deltas left it: author → that author's last `Ephemeral` data and
-         * when it arrived. The node replays a context's presence once, when the
-         * context is first subscribed on this connection, so a presence listener
-         * that comes later would never see it; {@link presenceSeed} gives it this.
-         */
-        this.presence = new Map();
-        this.closed = false;
-        this.listeners = { connect: [], event: [], error: [] };
-        this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
-        if (opts.authorize) {
-            this.authorize = opts.authorize;
-        }
-        else if (opts.getAuthToken) {
-            const getAuthToken = opts.getAuthToken;
-            this.authorize = async () => ({ Authorization: `Bearer ${await getAuthToken()}` });
-        }
-        else {
-            throw new Error('SseClient needs either `getAuthToken` or `authorize`');
-        }
-        this.reconnectDelayMs = opts.reconnectDelayMs ?? 3000;
-        // globalThis.fetch must be called as a method on globalThis, not through a
-        // variable, or browsers throw "Illegal invocation".
-        this.fetchImpl = (url, init) => opts.fetch ? opts.fetch(url, init) : globalThis.fetch(url, init);
-    }
-    on(event, handler) {
-        const key = event;
-        if (key in this.listeners) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const arr = this.listeners[key];
-            if (!arr.includes(handler))
-                arr.push(handler);
-        }
-    }
-    off(event, handler) {
-        const key = event;
-        if (key in this.listeners) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const arr = this.listeners[key];
-            const idx = arr.indexOf(handler);
-            if (idx !== -1)
-                arr.splice(idx, 1);
-        }
-    }
-    /**
-     * Typed convenience over the generic `'event'` stream: invokes `handler` only
-     * for `AppVersionChanged` context events, with the payload already parsed.
-     * Returns an unsubscribe closure (so callers need not retain the listener).
-     */
-    onAppVersionChanged(handler) {
-        const listener = (ev) => {
-            // Core flattens the tagged payload: the event carries `type` as a sibling
-            // of `data`, and `data` is the `{ fromVersion?, toVersion? }` payload.
-            if (ev.type !== 'AppVersionChanged')
-                return;
-            const d = ev.data;
-            handler({ contextId: ev.contextId, fromVersion: d?.fromVersion, toVersion: d?.toVersion });
-        };
-        this.on('event', listener);
-        return () => this.off('event', listener);
-    }
-    /**
-     * Typed convenience over the generic `'event'` stream: invokes `handler` only
-     * for group-migration events, narrowed on `type` so `data` is the matching
-     * payload. Returns an unsubscribe closure.
-     *
-     * A non-admin subscriber sees `MigrationStarted`, `MigrationProgress` and
-     * `MigrationCompleted` but never `CascadeProgress`, which core delivers to
-     * namespace admins only.
-     */
-    onMigrationEvent(handler) {
-        const listener = (ev) => {
-            if (isGroupMigrationEvent(ev))
-                handler(ev);
-        };
-        this.on('event', listener);
-        return () => this.off('event', listener);
-    }
-    emit(event, arg) {
-        const key = event;
-        if (key in this.listeners) {
-            for (const handler of this.listeners[key]) {
-                try {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    handler(arg);
-                }
-                catch {
-                    // Swallow handler errors
-                }
-            }
-        }
-    }
-    async connect() {
-        // Already connected — don't reconnect
-        if (this.abortController && !this.closed) {
-            return;
-        }
-        this.closed = false;
-        const controller = new AbortController();
-        this.abortController = controller;
-        try {
-            const url = `${this.baseUrl}/sse`;
-            const headers = {
-                ...(await this.authorize({ method: 'GET', path: signedPath(url) })),
-                'Accept': 'text/event-stream',
-            };
-            const proofAttached = carriesProof(headers);
-            const response = await this.fetchImpl(url, {
-                headers,
-                signal: controller.signal,
-                ...(proofAttached && { redirect: 'manual' }),
-            });
-            if (proofAttached)
-                refuseProofRedirect(response, url);
-            if (!response.ok) {
-                // Throw the same typed errors the request path throws. A bare
-                // `Error("SSE connection failed: 401")` forced callers to string-match
-                // the status and guess what it meant, and the honest guess — treat any
-                // 401 as fatal — logs the user out on a routine reconnect after the
-                // access token ages out, discarding a refresh token that was still
-                // good. The distinction is in the header; surface it.
-                const terminal = isTerminalAuthFailure(response);
-                const bodyText = await response.text().catch(() => undefined);
-                if (terminal) {
-                    throw new AuthRevokedError(terminal, response.status, response.statusText, url, response.headers, bodyText);
-                }
-                throw new HTTPError(response.status, response.statusText, url, response.headers, bodyText);
-            }
-            if (!response.body) {
-                throw new Error('SSE response has no body');
-            }
-            this.readStream(response.body, controller).catch((err) => {
-                if (this.superseded(controller))
-                    return;
-                const error = err instanceof Error ? err : new Error(String(err));
-                this.emit('error', error);
-                this.scheduleReconnect();
-            });
-        }
-        catch (err) {
-            if (this.superseded(controller))
-                return;
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.emit('error', error);
-            // Reconnecting against a revoked token family is a timer that never
-            // succeeds: every attempt re-sends the same dead credential. The caller
-            // has to re-authenticate, and an AuthRevokedError is how it is told.
-            if (error instanceof AuthRevokedError)
-                return;
-            this.scheduleReconnect();
-        }
-    }
-    /**
-     * Whether `controller`'s connection is no longer the one this client holds:
-     * closed, or replaced by a later connect. Its abort lands asynchronously,
-     * after a `close()` + `connect()` has already cleared `closed`, so `closed`
-     * alone cannot tell; reporting it, and reconnecting for it, would abort the
-     * live connection, whose own abort would do the same, without end.
-     */
-    superseded(controller) {
-        return this.closed || controller.signal.aborted || this.abortController !== controller;
-    }
-    async readStream(body, controller) {
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        try {
-            for (;;) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-                // Keep the last partial line in the buffer
-                buffer = lines.pop() ?? '';
-                for (const line of lines) {
-                    if (line.startsWith('data:')) {
-                        const jsonStr = line.slice(5).trim();
-                        if (jsonStr) {
-                            this.handleMessage(jsonStr);
-                        }
-                    }
-                }
-            }
-            // Flush remaining bytes from the decoder
-            buffer += decoder.decode();
-            if (buffer.startsWith('data:')) {
-                const jsonStr = buffer.slice(5).trim();
-                if (jsonStr) {
-                    this.handleMessage(jsonStr);
-                }
-            }
-        }
-        catch (err) {
-            if (this.superseded(controller))
-                return;
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.emit('error', error);
-        }
-        // Stream ended, reconnect
-        if (!this.superseded(controller)) {
-            this.scheduleReconnect();
-        }
-    }
-    handleMessage(jsonStr) {
-        try {
-            const msg = JSON.parse(jsonStr);
-            // Connection message
-            if (msg.type === 'connect' && msg.session_id) {
-                const sessionId = msg.session_id;
-                this.sessionId = sessionId;
-                // A new connection gets a new replay when it re-subscribes; what the
-                // old one said may name authors who have since gone.
-                this.presence.clear();
-                if (this.subscribedContextIds.size === 0 && this.subscribedGroupIds.size === 0) {
-                    this.emit('connect', sessionId);
-                    return;
-                }
-                // A new session starts subscribed to nothing, so announce it once the re-subscribe
-                // lands; a failed one still announces, then reports the error, as consumers saw before.
-                void this.postSubscription('subscribe', {
-                    contextIds: [...this.subscribedContextIds],
-                    groupIds: [...this.subscribedGroupIds],
-                }).then((failure) => {
-                    if (this.closed || this.sessionId !== sessionId)
-                        return;
-                    this.emit('connect', sessionId);
-                    if (failure)
-                        this.emit('error', failure);
-                });
-                return;
-            }
-            if (!msg.result)
-                return;
-            let eventData = msg.result.data;
-            // Decode byte-array data if needed
-            if (Array.isArray(eventData)) {
-                try {
-                    const bytes = new Uint8Array(eventData);
-                    const text = new TextDecoder().decode(bytes);
-                    eventData = JSON.parse(text);
-                }
-                catch {
-                    // Keep raw data
-                }
-            }
-            // Context event message
-            if (msg.result.contextId) {
-                if (msg.result.type === 'Ephemeral')
-                    this.notePresence(msg.result.contextId, eventData);
-                this.emit('event', {
-                    contextId: msg.result.contextId,
-                    // Forward the event tag (sibling of `data` in core's flattened
-                    // payload) so typed helpers like `onAppVersionChanged` can discriminate.
-                    type: msg.result.type,
-                    data: eventData,
-                });
-                return;
-            }
-            // Group-keyed event message (untagged NodeEvent's membership and
-            // migration variants; the `type` tag tells them apart).
-            if (msg.result.groupId) {
-                this.emit('event', {
-                    groupId: msg.result.groupId,
-                    type: msg.result.type,
-                    data: eventData,
-                });
-            }
-        }
-        catch {
-            // Invalid JSON, ignore
-        }
-    }
-    async subscribe(idsOrOpts) {
-        const opts = Array.isArray(idsOrOpts) ? { contextIds: idsOrOpts } : idsOrOpts;
-        const newContextIds = (opts.contextIds ?? []).filter(id => !this.subscribedContextIds.has(id));
-        const newGroupIds = (opts.groupIds ?? []).filter(id => !this.subscribedGroupIds.has(id));
-        for (const id of opts.contextIds ?? []) {
-            this.subscribedContextIds.add(id);
-        }
-        for (const id of opts.groupIds ?? []) {
-            this.subscribedGroupIds.add(id);
-        }
-        if ((newContextIds.length > 0 || newGroupIds.length > 0) && this.sessionId) {
-            await this.sendSubscription('subscribe', { contextIds: newContextIds, groupIds: newGroupIds });
-        }
-    }
-    /** Whether this connection holds `contextId`'s events. */
-    isSubscribed(contextId) {
-        return this.subscribedContextIds.has(contextId);
-    }
-    /**
-     * The presence currently known for `contextId`, as `Ephemeral` event data,
-     * each entry's `ageMs` advanced by how long ago it arrived. Empty for a
-     * context this connection does not hold.
-     */
-    presenceSeed(contextId) {
-        const now = Date.now();
-        return [...(this.presence.get(contextId)?.values() ?? [])].map(({ data, at }) => ({
-            ...data,
-            ageMs: (typeof data.ageMs === 'number' ? data.ageMs : 0) + (now - at),
-        }));
-    }
-    notePresence(contextId, data) {
-        if (!this.subscribedContextIds.has(contextId))
-            return;
-        const d = data;
-        if (!d || typeof d.author !== 'string')
-            return;
-        let byAuthor = this.presence.get(contextId);
-        if (!byAuthor)
-            this.presence.set(contextId, (byAuthor = new Map()));
-        if (d.removed)
-            byAuthor.delete(d.author);
-        else
-            byAuthor.set(d.author, { data: d, at: Date.now() });
-    }
-    async unsubscribe(idsOrOpts) {
-        const opts = Array.isArray(idsOrOpts) ? { contextIds: idsOrOpts } : idsOrOpts;
-        const hadContextIds = (opts.contextIds ?? []).filter(id => this.subscribedContextIds.has(id));
-        const hadGroupIds = (opts.groupIds ?? []).filter(id => this.subscribedGroupIds.has(id));
-        for (const id of opts.contextIds ?? []) {
-            this.subscribedContextIds.delete(id);
-            this.presence.delete(id);
-        }
-        for (const id of opts.groupIds ?? []) {
-            this.subscribedGroupIds.delete(id);
-        }
-        if ((hadContextIds.length > 0 || hadGroupIds.length > 0) && this.sessionId) {
-            await this.sendSubscription('unsubscribe', { contextIds: hadContextIds, groupIds: hadGroupIds });
-        }
-    }
-    async sendSubscription(method, ids) {
-        const failure = await this.postSubscription(method, ids);
-        if (failure)
-            this.emit('error', failure);
-    }
-    /** Sends one subscription change and returns why it failed, or `null`. */
-    async postSubscription(method, ids) {
-        const timeout = new AbortController();
-        const timer = setTimeout(() => timeout.abort(new DOMException(`SSE ${method} timed out`, 'TimeoutError')), SUBSCRIPTION_TIMEOUT_MS);
-        try {
-            const params = {};
-            if (ids.contextIds && ids.contextIds.length > 0)
-                params.contextIds = ids.contextIds;
-            if (ids.groupIds && ids.groupIds.length > 0)
-                params.groupIds = ids.groupIds;
-            const url = `${this.baseUrl}/sse/subscription`;
-            // Serialized once and both signed and sent, because a proof commits to the
-            // body: re-stringifying for the signature risks two byte sequences that
-            // differ in key order, which fails as a refused credential rather than as
-            // anything that names the real cause.
-            const body = JSON.stringify({ id: this.sessionId, method, params });
-            const headers = {
-                ...(await this.authorize({ method: 'POST', path: signedPath(url), body })),
-                'Content-Type': 'application/json',
-            };
-            const proofAttached = carriesProof(headers);
-            const response = await this.fetchImpl(url, {
-                method: 'POST',
-                headers,
-                body,
-                signal: timeout.signal,
-                ...(proofAttached && { redirect: 'manual' }),
-            });
-            if (proofAttached)
-                refuseProofRedirect(response, url);
-            if (!response.ok) {
-                // The subscribe path used to report only the status. On the one failure
-                // that matters it is the whole of what the caller got: a revoked family
-                // answers 403 with an empty body, so a bare `SSE subscribe failed: 403`
-                // discarded the only evidence of what went wrong — and a 403 here reads
-                // identically to the unrelated "not the session owner" refusal, which
-                // does carry a body.
-                const terminal = isTerminalAuthFailure(response);
-                const bodyText = await response.text().catch(() => undefined);
-                return terminal
-                    ? new AuthRevokedError(terminal, response.status, response.statusText, `${this.baseUrl}/sse/subscription`, response.headers, bodyText)
-                    : new HTTPError(response.status, response.statusText, `${this.baseUrl}/sse/subscription`, response.headers, bodyText);
-            }
-            return null;
-        }
-        catch (err) {
-            return err instanceof Error ? err : new Error(`SSE ${method} failed`);
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    forceReconnect() {
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = null;
-        }
-        this.sessionId = null;
-        this.connect();
-    }
-    scheduleReconnect() {
-        if (this.closed)
-            return;
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-        }
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            this.forceReconnect();
-        }, this.reconnectDelayMs);
-    }
-    close() {
-        this.closed = true;
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = null;
-        }
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.sessionId = null;
-        this.subscribedContextIds.clear();
-        this.subscribedGroupIds.clear();
-    }
-}

package/dist/events/ws.d.ts

@@ -1,57 +0,0 @@
-import type { GroupMembershipEventData, GroupMigrationEventData } from './group.js';
-export type { GroupMembershipEventData, GroupMigrationEventData };
-export interface WsEventData {
-    contextId: string;
-    /** The context-event discriminator (core serializes it as a sibling of
-     * `data`, e.g. `"AppVersionChanged"`). Undefined for events without a tag. */
-    type?: string;
-    data: unknown;
-}
-/** Anything the `'event'` stream can deliver: context events plus the
- * group-keyed membership and migration families. */
-type WsEvent = WsEventData | GroupMembershipEventData | GroupMigrationEventData;
-type WsEventHandler = (event: WsEvent) => void;
-type WsConnectHandler = () => void;
-type WsErrorHandler = (error: Error) => void;
-/**
- * @experimental WebSocket event client. The SSE client (`SseClient`) is the
- * recommended transport for production — use `MeroJs.events` instead of `MeroJs.ws`.
- */
-export declare class WsClient {
-    private baseUrl;
-    private getAuthToken;
-    private ws;
-    private closed;
-    private reconnectAttempt;
-    private reconnectTimer;
-    private subscribedContextIds;
-    private subscribedGroupIds;
-    private listeners;
-    private static readonly MAX_BACKOFF_MS;
-    constructor(opts: {
-        baseUrl: string;
-        getAuthToken: () => Promise<string>;
-    });
-    on(event: 'connect', handler: WsConnectHandler): void;
-    on(event: 'event', handler: WsEventHandler): void;
-    on(event: 'error', handler: WsErrorHandler): void;
-    off(event: 'connect', handler: WsConnectHandler): void;
-    off(event: 'event', handler: WsEventHandler): void;
-    off(event: 'error', handler: WsErrorHandler): void;
-    private emit;
-    connect(): Promise<void>;
-    private handleMessage;
-    subscribe(idsOrOpts: string[] | {
-        contextIds?: string[];
-        groupIds?: string[];
-    }): void;
-    unsubscribe(idsOrOpts: string[] | {
-        contextIds?: string[];
-        groupIds?: string[];
-    }): void;
-    private resubscribeAfterReconnect;
-    private buildSubscriptionParams;
-    private sendMessage;
-    private scheduleReconnect;
-    close(): void;
-}