snapreq 0.0.1 → 0.0.4

package/types/transports/node-transport.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Full-featured transport backed by Node's `http`/`https` modules. Supports
+ * Unix sockets, client TLS, keep-alive, request-body compression, response
+ * decompression and streaming. The `node:*` modules are loaded with a dynamic
+ * `import()` so this file never has to be bundled by web/Expo bundlers — the
+ * transport selector only imports it when running on Node.
+ */
+export default class NodeTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName(): string;
+    /** @returns {boolean} - Whether this transport can run in the current environment. */
+    static isAvailable(): boolean;
+    /**
+     * @param {object} [config] - Transport configuration.
+     * @param {string} [config.socketPath] - Unix domain socket path.
+     * @param {{ca?: string | Buffer, cert?: string | Buffer, key?: string | Buffer, rejectUnauthorized?: boolean}} [config.tls] - TLS material for HTTPS connections.
+     * @param {boolean} [config.keepAlive] - Reuse connections across requests. Defaults to true.
+     */
+    constructor({ socketPath, tls, keepAlive }?: {
+        socketPath?: string;
+        tls?: {
+            ca?: string | Buffer;
+            cert?: string | Buffer;
+            key?: string | Buffer;
+            rejectUnauthorized?: boolean;
+        };
+        keepAlive?: boolean;
+    });
+    socketPath: string;
+    tls: {
+        ca?: string | Buffer;
+        cert?: string | Buffer;
+        key?: string | Buffer;
+        rejectUnauthorized?: boolean;
+    };
+    keepAlive: boolean;
+    /** @type {{http: any, https: any, zlib: any, stream: any} | null} */
+    _modules: {
+        http: any;
+        https: any;
+        zlib: any;
+        stream: any;
+    } | null;
+    /** @type {any} */
+    _httpAgent: any;
+    /** @type {any} */
+    _httpsAgent: any;
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities(): import("../capabilities.js").TransportCapabilities;
+    /** @returns {Promise<{http: any, https: any, zlib: any, stream: any}>} - Lazily-loaded Node modules. */
+    _load(): Promise<{
+        http: any;
+        https: any;
+        zlib: any;
+        stream: any;
+    }>;
+    /**
+     * @param {boolean} useTls - Whether the request uses TLS.
+     * @returns {any} - The keep-alive agent for the protocol.
+     */
+    _agent(useTls: boolean): any;
+    /**
+     * Performs a single request and resolves once the response headers arrive,
+     * exposing the (decoded) body as a stream so callers can buffer or stream it.
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    performRequest(request: import("../snap-req.js").NormalizedRequest): Promise<SnapReqResponse>;
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @param {SnapReqHeaders} headers - Headers, mutated with Content-Length / Content-Encoding.
+     * @param {{zlib: any, stream: any}} modules - Node modules.
+     * @returns {{buffer: Buffer | null, stream: import("node:stream").Readable | null}} - Prepared body.
+     */
+    _prepareRequestBody(request: import("../snap-req.js").NormalizedRequest, headers: SnapReqHeaders, { zlib, stream }: {
+        zlib: any;
+        stream: any;
+    }): {
+        buffer: Buffer | null;
+        stream: import("node:stream").Readable | null;
+    };
+    /**
+     * @param {string} encoding - Compression encoding.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Transform} - A compressor transform.
+     */
+    _requestCompressor(encoding: string, zlib: any): import("node:stream").Transform;
+    /**
+     * @param {import("node:http").IncomingMessage} response - The raw response.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Readable} - The decoded response body stream.
+     */
+    _decodeResponseStream(response: import("node:http").IncomingMessage, zlib: any): import("node:stream").Readable;
+    /**
+     * @param {string} encoding - Content encoding.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Transform} - A decompressor transform.
+     */
+    _responseDecoder(encoding: string, zlib: any): import("node:stream").Transform;
+    /**
+     * @param {import("node:http").IncomingMessage} response - The raw response.
+     * @returns {SnapReqHeaders} - The response headers.
+     */
+    _responseHeaders(response: import("node:http").IncomingMessage): SnapReqHeaders;
+    /**
+     * Destroys the keep-alive agents, closing all persistent connections.
+     * @returns {void}
+     */
+    close(): void;
+}
+import SnapReqResponse from "../response.js";
+import SnapReqHeaders from "../headers.js";

package/types/transports/select.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @typedef {"auto" | "node" | "fetch" | "xhr"} TransportName
+ */
+/**
+ * @typedef {object} Transport
+ * @property {import("../capabilities.js").TransportCapabilities} capabilities - Supported capabilities.
+ * @property {(request: import("../snap-req.js").NormalizedRequest) => Promise<import("../response.js").default>} performRequest - Perform a request.
+ * @property {() => void} [close] - Optional resource cleanup.
+ */
+/**
+ * Detects the JavaScript runtime so `auto` can pick the right transport.
+ * @returns {"node" | "react-native" | "browser" | "unknown"} - Detected runtime.
+ */
+export function detectRuntime(): "node" | "react-native" | "browser" | "unknown";
+/**
+ * Resolves a transport for the requested preference. Returns the preference
+ * untouched when it is already a transport instance. The Node transport is
+ * imported dynamically so web/Expo bundlers never pull in `node:*` modules.
+ * @param {TransportName | Transport | undefined} preference - Requested transport.
+ * @param {object} nodeConfig - Configuration forwarded to the Node transport.
+ * @returns {Promise<Transport>} - The resolved transport.
+ */
+export function selectTransport(preference: TransportName | Transport | undefined, nodeConfig: object): Promise<Transport>;
+export type TransportName = "auto" | "node" | "fetch" | "xhr";
+export type Transport = {
+    /**
+     * - Supported capabilities.
+     */
+    capabilities: import("../capabilities.js").TransportCapabilities;
+    /**
+     * - Perform a request.
+     */
+    performRequest: (request: import("../snap-req.js").NormalizedRequest) => Promise<import("../response.js").default>;
+    /**
+     * - Optional resource cleanup.
+     */
+    close?: () => void;
+};

package/types/transports/xhr-transport.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Transport backed by `XMLHttpRequest`. A fallback for web environments that
+ * lack `fetch`. Buffers the whole response (no incremental streaming) and, like
+ * `fetch`, cannot do Unix sockets, client TLS or request-body compression.
+ */
+export default class XhrTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName(): string;
+    /** @returns {boolean} - Whether this transport can run in the current environment. */
+    static isAvailable(): boolean;
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities(): import("../capabilities.js").TransportCapabilities;
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    performRequest(request: import("../snap-req.js").NormalizedRequest): Promise<SnapReqResponse>;
+    /**
+     * @param {string} rawHeaders - Raw header block from `getAllResponseHeaders`.
+     * @returns {SnapReqHeaders} - The parsed response headers.
+     */
+    _parseHeaders(rawHeaders: string): SnapReqHeaders;
+}
+import SnapReqResponse from "../response.js";
+import SnapReqHeaders from "../headers.js";

package/types/websocket/websocket-channel.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Client-side handle for a channel subscription opened via
+ * `SnapReqWebSocketClient.subscribeChannel()`. Mirrors the server's
+ * subscription lifecycle — `subscribed` (resolves `ready`) / `onMessage` /
+ * `onClose`.
+ */
+export default class SnapReqWebSocketChannel {
+    /**
+     * @param {object} args - Channel arguments.
+     * @param {import("./websocket-client.js").default} args.client - Owning client.
+     * @param {string} args.subscriptionId - Generated id unique within the session.
+     * @param {string} args.channelType - Name the server registered the channel under.
+     * @param {Record<string, any>} [args.params] - Opaque params forwarded to the server.
+     * @param {string} [args.lastEventId] - Resume replay from this event id.
+     * @param {(body: any) => void} [args.onMessage] - Fired on each `channel-message` from the server.
+     * @param {() => void} [args.onDisconnect] - Fired when the socket drops.
+     * @param {() => void} [args.onResume] - Fired when the session resumes after a drop.
+     * @param {(reason: string) => void} [args.onClose] - Fired exactly once when the subscription closes permanently.
+     */
+    constructor({ client, subscriptionId, channelType, params, lastEventId, onMessage, onDisconnect, onResume, onClose }: {
+        client: import("./websocket-client.js").default;
+        subscriptionId: string;
+        channelType: string;
+        params?: Record<string, any>;
+        lastEventId?: string;
+        onMessage?: (body: any) => void;
+        onDisconnect?: () => void;
+        onResume?: () => void;
+        onClose?: (reason: string) => void;
+    });
+    client: import("./websocket-client.js").default;
+    subscriptionId: string;
+    channelType: string;
+    params: Record<string, any>;
+    lastEventId: string;
+    _onMessage: (body: any) => void;
+    _onDisconnect: () => void;
+    _onResume: () => void;
+    _onClose: (reason: string) => void;
+    _ready: boolean;
+    _resumeReadyOnResume: boolean;
+    _subscribed: boolean;
+    _subscribeSent: boolean;
+    _closed: boolean;
+    /** @returns {Promise<void>} - Resolves once the subscription is acknowledged. */
+    _ensureReadyPromise(): Promise<void>;
+    /** @type {Promise<void>} */
+    _readyPromise: Promise<void>;
+    _resolveReady: (value: void | PromiseLike<void>) => void;
+    _rejectReady: (reason?: any) => void;
+    /** @returns {Promise<void>} - Resolves once the subscription is acknowledged. */
+    get ready(): Promise<void>;
+    /** @returns {void} */
+    _resolveReadyState(): void;
+    /** @returns {void} */
+    _markNotReady(): void;
+    /** @returns {void} */
+    _handleSubscribed(): void;
+    /** @returns {void} */
+    _markSubscribeSent(): void;
+    /** @returns {boolean} - Whether the subscription still needs to be sent. */
+    _needsSubscribe(): boolean;
+    /**
+     * @param {any} body - Message payload.
+     * @returns {void}
+     */
+    _handleMessage(body: any): void;
+    /** @returns {void} */
+    _handleDisconnected(): void;
+    /** @returns {void} */
+    _handleResumed(): void;
+    /**
+     * @param {string} reason - Why the subscription closed.
+     * @returns {void}
+     */
+    _handleClosed(reason: string): void;
+    /**
+     * @param {{timeoutMs?: number}} [params] - Options.
+     * @returns {Promise<void>} - Resolves once ready or rejects on timeout.
+     */
+    waitForReady({ timeoutMs }?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /** @returns {void} */
+    close(): void;
+    /** @returns {boolean} - Whether the subscription is closed. */
+    isClosed(): boolean;
+    /** @returns {boolean} - Whether the subscription is acknowledged and ready. */
+    isReady(): boolean;
+    /** @returns {boolean} - Whether the subscription is active. */
+    isSubscribed(): boolean;
+}

package/types/websocket/websocket-client.d.ts

@@ -0,0 +1,364 @@
+/**
+ * A small WebSocket client that mirrors simple HTTP-style calls and channel
+ * subscriptions over `globalThis.WebSocket`, so the same code runs on web, Expo
+ * / React Native and Node. Supports optional auto-reconnect with exponential
+ * backoff, session resumption and listener re-subscription.
+ *
+ * Response bodies are returned as raw parsed JSON; apps that need their own
+ * (de)serialization should apply it around `post`/`get` and the response
+ * `json()`.
+ */
+export default class SnapReqWebSocketClient {
+    /**
+     * @param {object} args - Options object.
+     * @param {string} args.url - Full WebSocket URL, e.g. `ws://localhost:3006/websocket`.
+     * @param {boolean} [args.autoReconnect] - Enable auto-reconnect with exponential backoff.
+     * @param {boolean} [args.debug] - Whether to log debug output.
+     * @param {{getIsOnline?: () => boolean | Promise<boolean>, subscribe?: (callback: (isOnline: boolean) => void) => (() => void) | {remove: () => void}}} [args.networkMonitor] - Optional online-state adapter. When provided, auto-reconnect can wait for the network to report online before reconnecting, and open sockets are closed when the monitor reports offline.
+     * @param {number[]} [args.reconnectDelays] - Backoff delays in ms (default: [1000, 2000, 4000, 8000, 15000]).
+     * @param {{get: () => string | null | undefined | Promise<string | null | undefined>, set: (sessionId: string) => void | Promise<void>, clear: () => void | Promise<void>}} [args.sessionStore] - Optional sessionId persistence hook surviving reloads (localStorage, a cookie, SQLite, etc.).
+     * @param {(value: any) => any} [args.deserialize] - Optional transform applied to a response body inside `response.json()`. Lets an app re-hydrate its own wire format. Defaults to identity.
+     */
+    constructor({ autoReconnect, debug, deserialize, networkMonitor, reconnectDelays, sessionStore, url }?: {
+        url: string;
+        autoReconnect?: boolean;
+        debug?: boolean;
+        networkMonitor?: {
+            getIsOnline?: () => boolean | Promise<boolean>;
+            subscribe?: (callback: (isOnline: boolean) => void) => (() => void) | {
+                remove: () => void;
+            };
+        };
+        reconnectDelays?: number[];
+        sessionStore?: {
+            get: () => string | null | undefined | Promise<string | null | undefined>;
+            set: (sessionId: string) => void | Promise<void>;
+            clear: () => void | Promise<void>;
+        };
+        deserialize?: (value: any) => any;
+    });
+    /** @type {Map<string, {reject: (error: unknown) => void, resolve: (response: SnapReqWebSocketResponse) => void}>} */
+    pendingRequests: Map<string, {
+        reject: (error: unknown) => void;
+        resolve: (response: SnapReqWebSocketResponse) => void;
+    }>;
+    /** @type {Map<string, {reject: (error: unknown) => void, resolve: (value?: void) => void}>} */
+    pendingSubscriptions: Map<string, {
+        reject: (error: unknown) => void;
+        resolve: (value?: void) => void;
+    }>;
+    /** @type {Map<string, {callbacks: Set<(payload: any) => void>, channel: string, params: Record<string, any> | undefined, ready: Promise<void>}>} */
+    listeners: Map<string, {
+        callbacks: Set<(payload: any) => void>;
+        channel: string;
+        params: Record<string, any> | undefined;
+        ready: Promise<void>;
+    }>;
+    /** @type {(value: any) => any} */
+    _deserialize: (value: any) => any;
+    /** @type {boolean} */
+    autoReconnect: boolean;
+    debug: boolean;
+    /** @type {number | null} */
+    disconnectedSince: number | null;
+    /** @type {number} */
+    reconnectAttempt: number;
+    /** @type {number} */
+    connectionAttempts: number;
+    /** @type {number[]} */
+    reconnectDelays: number[];
+    /** @type {ReturnType<typeof setTimeout> | null} */
+    reconnectTimer: ReturnType<typeof setTimeout> | null;
+    url: string;
+    nextID: number;
+    /** @type {(() => void | Promise<void>) | null} */
+    onReconnect: (() => void | Promise<void>) | null;
+    /** @type {Record<string, any>} */
+    _metadata: Record<string, any>;
+    /** @type {Map<string, SnapReqWebSocketConnection>} */
+    _connections: Map<string, SnapReqWebSocketConnection>;
+    /** @type {Map<string, SnapReqWebSocketChannel>} */
+    _channelSubscriptions: Map<string, SnapReqWebSocketChannel>;
+    _nextConnectionIdSeq: number;
+    _nextSubscriptionIdSeq: number;
+    /** @type {string | null} - sessionId received from `session-established`; sent on reconnect for resumption. */
+    _sessionId: string | null;
+    /** @type {boolean} - true between a reconnect and the session-resumed / session-gone reply. */
+    _awaitingResume: boolean;
+    /** @type {boolean} - true once the current socket has an active session ready for app messages. */
+    _sessionReady: boolean;
+    /** @type {string | null} - provisional session id announced before a resume attempt finishes. */
+    _pendingSessionId: string | null;
+    /** @type {Promise<void> | null} */
+    _sessionReadyPromise: Promise<void> | null;
+    /** @type {(() => void) | null} */
+    _resolveSessionReady: (() => void) | null;
+    /** @type {unknown | null} */
+    _sessionReadyError: unknown | null;
+    /** @type {{get: () => string | null | undefined | Promise<string | null | undefined>, set: (sessionId: string) => void | Promise<void>, clear: () => void | Promise<void>} | undefined} */
+    _sessionStore: {
+        get: () => string | null | undefined | Promise<string | null | undefined>;
+        set: (sessionId: string) => void | Promise<void>;
+        clear: () => void | Promise<void>;
+    } | undefined;
+    /** @type {boolean} - true once the sessionStore has been consulted for a restored id. */
+    _sessionStoreRestored: boolean;
+    /** @type {{getIsOnline?: () => boolean | Promise<boolean>, subscribe?: (callback: (isOnline: boolean) => void) => (() => void) | {remove: () => void}} | undefined} */
+    _networkMonitor: {
+        getIsOnline?: () => boolean | Promise<boolean>;
+        subscribe?: (callback: (isOnline: boolean) => void) => (() => void) | {
+            remove: () => void;
+        };
+    } | undefined;
+    /** @type {null | (() => void) | {remove: () => void}} */
+    _networkMonitorSubscription: null | (() => void) | {
+        remove: () => void;
+    };
+    /** @type {boolean} */
+    _waitingForOnline: boolean;
+    /** @returns {boolean} - Whether the socket is open. */
+    isOpen(): boolean;
+    /** @returns {boolean} - Whether the session is ready for app messages. */
+    isSessionReady(): boolean;
+    /**
+     * Opens a 1:1 connection of the given type against the server. Requires the
+     * socket to already be connected (call `connect()` first).
+     * @param {string} connectionType - Name the server registered the class under.
+     * @param {{params?: Record<string, any>, onConnect?: () => void, onMessage?: (body: any) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Connection options.
+     * @returns {SnapReqWebSocketConnection} - The connection handle.
+     */
+    openConnection(connectionType: string, options?: {
+        params?: Record<string, any>;
+        onConnect?: () => void;
+        onMessage?: (body: any) => void;
+        onDisconnect?: () => void;
+        onResume?: () => void;
+        onClose?: (reason: string) => void;
+    }): SnapReqWebSocketConnection;
+    /**
+     * Drops a connection handle from the registry.
+     * @param {string} connectionId - The connection id.
+     * @returns {void}
+     */
+    _removeConnection(connectionId: string): void;
+    /**
+     * Subscribes to a named channel. If the socket is not yet open, the
+     * subscription is queued and sent once a connection is established.
+     * @param {string} channelType - Name the server registered the channel under.
+     * @param {{params?: Record<string, any>, lastEventId?: string, onMessage?: (body: any) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Subscription options.
+     * @returns {SnapReqWebSocketChannel} - The subscription handle.
+     */
+    subscribeChannel(channelType: string, options?: {
+        params?: Record<string, any>;
+        lastEventId?: string;
+        onMessage?: (body: any) => void;
+        onDisconnect?: () => void;
+        onResume?: () => void;
+        onClose?: (reason: string) => void;
+    }): SnapReqWebSocketChannel;
+    /**
+     * @param {string} subscriptionId - The subscription id.
+     * @returns {void}
+     */
+    _removeChannelSubscription(subscriptionId: string): void;
+    /**
+     * @param {SnapReqWebSocketChannel} subscription - The subscription to send.
+     * @returns {void}
+     */
+    _sendChannelSubscribe(subscription: SnapReqWebSocketChannel): void;
+    /** @returns {void} */
+    _sendPendingChannelSubscriptions(): void;
+    /** @returns {Promise<boolean>} - Whether the network reports online. */
+    _isOnline(): Promise<boolean>;
+    /** @returns {Promise<boolean>} - Whether reconnect should wait for online. */
+    _shouldWaitForOnline(): Promise<boolean>;
+    /** @returns {void} */
+    _ensureNetworkMonitorSubscription(): void;
+    /** @returns {void} */
+    _teardownNetworkMonitorSubscription(): void;
+    /**
+     * Sets a global metadata value that is sent to the server. When the socket is
+     * open, a metadata update message is sent immediately.
+     * @param {string} key - Metadata key.
+     * @param {any} value - Metadata value (null to clear).
+     * @returns {void}
+     */
+    setMetadata(key: string, value: any): void;
+    /** @returns {Record<string, any>} - Current metadata. */
+    getMetadata(): Record<string, any>;
+    /**
+     * Ensures a WebSocket connection is open. Auto-reconnect and online gating are
+     * enabled by default.
+     * @param {{autoReconnect?: boolean, waitForOnline?: boolean, resetReconnectState?: boolean}} [options] - Connect options.
+     * @returns {Promise<void>} - Resolves once connected and the session is ready.
+     */
+    connect({ autoReconnect, waitForOnline, resetReconnectState }?: {
+        autoReconnect?: boolean;
+        waitForOnline?: boolean;
+        resetReconnectState?: boolean;
+    }): Promise<void>;
+    connectPromise: Promise<any>;
+    socket: WebSocket;
+    /**
+     * Closes the WebSocket and clears pending state.
+     * @returns {Promise<void>} - Resolves once closed.
+     */
+    close(): Promise<void>;
+    /**
+     * Disables auto-reconnect and closes the WebSocket.
+     * @returns {Promise<void>} - Resolves once closed.
+     */
+    disconnectAndStopReconnect(): Promise<void>;
+    /**
+     * Closes the raw socket without disabling auto-reconnect. Used by tests to
+     * simulate an unexpected network drop.
+     * @returns {Promise<void>} - Resolves once the socket has closed.
+     */
+    dropConnection(): Promise<void>;
+    /**
+     * Performs a POST request over the WebSocket.
+     * @param {string} path - Path.
+     * @param {any} [body] - Request body.
+     * @param {{headers?: Record<string, string>}} [options] - Request options such as headers.
+     * @returns {Promise<SnapReqWebSocketResponse>} - The response.
+     */
+    post(path: string, body?: any, options?: {
+        headers?: Record<string, string>;
+    }): Promise<SnapReqWebSocketResponse>;
+    /**
+     * Performs a GET request over the WebSocket.
+     * @param {string} path - Path.
+     * @param {{headers?: Record<string, string>}} [options] - Request options such as headers.
+     * @returns {Promise<SnapReqWebSocketResponse>} - The response.
+     */
+    get(path: string, options?: {
+        headers?: Record<string, string>;
+    }): Promise<SnapReqWebSocketResponse>;
+    /**
+     * Subscribes to a channel for server-sent events.
+     * @param {string} channel - Channel name.
+     * @param {(payload: any) => void} callback - Callback function.
+     * @returns {() => void} - Unsubscribe function.
+     */
+    on(channel: string, callback: (payload: any) => void): () => void;
+    /**
+     * Returns a snapshot of the client's connection state.
+     * @returns {{disconnectedSince: number | null, isOpen: boolean, listenerCount: number}} - State snapshot.
+     */
+    state(): {
+        disconnectedSince: number | null;
+        isOpen: boolean;
+        listenerCount: number;
+    };
+    /**
+     * Subscribes to a channel for server-sent events with optional params.
+     * @param {string} channel - Channel name.
+     * @param {{lastEventId?: string, params?: Record<string, any>}} options - Subscription options.
+     * @param {(payload: any, message?: Record<string, any>) => void} callback - Callback function.
+     * @returns {(() => void) & {ready: Promise<void>}} - Unsubscribe function with readiness promise.
+     */
+    subscribe(channel: string, options: {
+        lastEventId?: string;
+        params?: Record<string, any>;
+    }, callback: (payload: any, message?: Record<string, any>) => void): (() => void) & {
+        ready: Promise<void>;
+    };
+    /**
+     * Subscribes to a channel and waits until the server acknowledges it.
+     * @param {string} channel - Channel name.
+     * @param {{lastEventId?: string, params?: Record<string, any>}} options - Subscription options.
+     * @param {(payload: any, message?: Record<string, any>) => void} callback - Callback function.
+     * @returns {Promise<(() => void) & {ready: Promise<void>}>} - Ready unsubscribe handle.
+     */
+    subscribeAndWait(channel: string, options: {
+        lastEventId?: string;
+        params?: Record<string, any>;
+    }, callback: (payload: any, message?: Record<string, any>) => void): Promise<(() => void) & {
+        ready: Promise<void>;
+    }>;
+    /**
+     * @param {string} method - HTTP method.
+     * @param {string} path - Path.
+     * @param {object} [options] - Options object.
+     * @param {any} [options.body] - Request body.
+     * @param {Record<string, string>} [options.headers] - Header list.
+     * @returns {Promise<SnapReqWebSocketResponse>} - The response.
+     */
+    request(method: string, path: string, { body, headers }?: {
+        body?: any;
+        headers?: Record<string, string>;
+    }): Promise<SnapReqWebSocketResponse>;
+    /**
+     * @param {MessageEvent<any>} event - Event payload.
+     * @returns {void}
+     */
+    onMessage: (event: MessageEvent<any>) => void;
+    /**
+     * @param {string} channel - Channel name.
+     * @param {Record<string, any> | undefined} params - Subscription params.
+     * @returns {string} - Stable subscription key.
+     */
+    _subscriptionKey(channel: string, params: Record<string, any> | undefined): string;
+    /**
+     * Rejects all pending requests when the socket closes. Schedules reconnect if
+     * enabled.
+     * @returns {void}
+     */
+    onClose: () => void;
+    /**
+     * @param {Record<string, any>} payload - Payload data.
+     * @returns {void}
+     */
+    _sendMessage(payload: Record<string, any>): void;
+    /** @returns {void} */
+    _cancelPendingReconnect(): void;
+    /** @returns {void} */
+    _scheduleReconnect(): void;
+    /** @returns {Promise<void>} */
+    _attemptReconnect(): Promise<void>;
+    /**
+     * Re-sends subscribe messages for all active listeners after reconnection.
+     * @returns {void}
+     */
+    _resubscribeActiveListeners(): void;
+    /**
+     * @param  {...any} args - Log arguments.
+     * @returns {void}
+     */
+    _debug(...args: any[]): void;
+    /**
+     * @param {string} sessionId - Id to persist through the configured sessionStore.
+     * @returns {void}
+     */
+    _persistSessionId(sessionId: string): void;
+    /** @returns {void} */
+    _clearPersistedSessionId(): void;
+    /** @returns {Promise<void>} - Resolves once the session is ready. */
+    _waitForSessionReady(): Promise<void>;
+    /** @returns {void} */
+    _markSessionReady(): void;
+    /**
+     * @param {unknown} [error] - Reason for the reset.
+     * @returns {void}
+     */
+    _resetSessionReadyState(error?: unknown): void;
+}
+/** A response to a request made over the WebSocket transport. */
+export class SnapReqWebSocketResponse {
+    /**
+     * @param {object} message - The response message.
+     * @param {(value: any) => any} [deserialize] - Transform applied to the parsed body in `json()`. Defaults to identity.
+     */
+    constructor(message: object, deserialize?: (value: any) => any);
+    body: any;
+    headers: Record<string, any>;
+    id: string | number;
+    statusCode: number;
+    statusMessage: string;
+    type: string;
+    _deserialize: (value: any) => any;
+    /** @returns {any} - The parsed (and optionally deserialized) JSON body. */
+    json(): any;
+}
+import SnapReqWebSocketConnection from "./websocket-connection.js";
+import SnapReqWebSocketChannel from "./websocket-channel.js";