@stream-io/video-client 0.0.1-alpha.7

package/dist/src/Batcher.d.ts

@@ -0,0 +1,12 @@
+export declare class Batcher<BatchItemType> {
+    private readonly timeoutInterval;
+    private readonly requestFunction;
+    private batch;
+    private timeoutId;
+    constructor(timeoutInterval: number, requestFunction: (data: Array<BatchItemType>) => void);
+    private scheduleTimeout;
+    private clearTimeout;
+    clearBatch: () => void;
+    addToBatch: (item: BatchItemType) => void;
+    removeFromBatch: (item: BatchItemType) => void;
+}

package/dist/src/CallDropScheduler.d.ts

@@ -0,0 +1,44 @@
+import { StreamVideoWriteableStateStore } from './store';
+import { CallConfig } from './config/types';
+type CallCID = string;
+type DropFunction = (callCid: CallCID) => Promise<void>;
+export declare class CallDropScheduler {
+    private store;
+    private callConfig;
+    private reject;
+    private cancel;
+    private autoCallDropSchedule;
+    private storeSubscriptions;
+    private pairwisePendingCalls$;
+    private pairwiseIncomingCalls$;
+    private pairwiseOutgoingCalls$;
+    constructor(store: StreamVideoWriteableStateStore, callConfig: CallConfig, reject: DropFunction, cancel: DropFunction);
+    private static getLatestCall;
+    private startAutoRejectWhenInCall;
+    private scheduleRejectAfterTimeout;
+    private scheduleCancelAfterTimeout;
+    private startCancellingDrops;
+    /**
+     * Schedules automatic call cancellation.
+     * The cancellation is intended for the scenarios, when the call has been rejected
+     * or not accepted by all the call members.
+     * @param {string} callCid
+     */
+    private scheduleCancel;
+    /**
+     * Schedules automatic call rejection.
+     * @param {string} callCid
+     */
+    private scheduleReject;
+    /**
+     * Cancels the automatic call drop (rejection of an incoming call / cancellation of an outgoing call).
+     * Indented for the scenario, when:
+     * - an incoming call has been cancelled
+     * - an outgoing call has been accepted by at least one member
+     * - an outgoing call has been rejected / left by all the members resp. participants
+     * - a call has been cancelled / rejected / accepted manually before the cancellation timeout expires.
+     */
+    private cancelDrop;
+    cleanUp: () => void;
+}
+export {};

package/dist/src/StreamSfuClient.d.ts

@@ -0,0 +1,25 @@
+import { JoinRequest, SfuRequest } from './gen/video/sfu/event/events';
+import { Dispatcher } from './rtc/Dispatcher';
+import { IceTrickleBuffer } from './rtc/IceTrickleBuffer';
+import { SendAnswerRequest, SetPublisherRequest, TrackSubscriptionDetails, UpdateMuteStatesRequest } from './gen/video/sfu/signal_rpc/signal';
+import { ICETrickle, TrackType } from './gen/video/sfu/models/models';
+export declare class StreamSfuClient {
+    readonly dispatcher: Dispatcher;
+    readonly iceTrickleBuffer: IceTrickleBuffer;
+    readonly sessionId: string;
+    private readonly rpc;
+    private readonly token;
+    signalReady: Promise<WebSocket>;
+    private keepAliveInterval?;
+    constructor(url: string, token: string);
+    close: () => void;
+    updateSubscriptions: (subscriptions: TrackSubscriptionDetails[]) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").UpdateSubscriptionsRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateSubscriptionsResponse>>;
+    setPublisher: (data: Omit<SetPublisherRequest, 'sessionId'>) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<SetPublisherRequest, import("./gen/video/sfu/signal_rpc/signal").SetPublisherResponse>>;
+    sendAnswer: (data: Omit<SendAnswerRequest, 'sessionId'>) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<SendAnswerRequest, import("./gen/video/sfu/signal_rpc/signal").SendAnswerResponse>>;
+    iceTrickle: (data: Omit<ICETrickle, 'sessionId'>) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<ICETrickle, import("./gen/video/sfu/signal_rpc/signal").ICETrickleResponse>>;
+    updateMuteState: (trackType: TrackType, muted: boolean) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
+    updateMuteStates: (data: Omit<UpdateMuteStatesRequest, 'sessionId'>) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
+    join: (data: Omit<JoinRequest, 'sessionId' | 'token'>) => Promise<void>;
+    send: (message: SfuRequest) => Promise<void>;
+    keepAlive(): Promise<void>;
+}

package/dist/src/StreamVideoClient.d.ts

@@ -0,0 +1,145 @@
+import { StreamVideoReadOnlyStateStore } from './store';
+import type { GetOrCreateCallRequest } from './gen/coordinator';
+import { Call } from './rtc/Call';
+import { Batcher } from './Batcher';
+import { CallConfig } from './config/types';
+import { EventHandler, StreamClientOptions, TokenOrProvider, User } from './coordinator/connection/types';
+/**
+ * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
+ */
+export declare class StreamVideoClient {
+    /**
+     * Configuration parameters for controlling call behavior.
+     */
+    callConfig: CallConfig;
+    /**
+     * A reactive store that exposes all the state variables in a reactive manner - you can subscribe to changes of the different state variables. Our library is built in a way that all state changes are exposed in this store, so all UI changes in your application should be handled by subscribing to these variables.
+     * @angular If you're using our Angular SDK, you shouldn't be interacting with the state store directly, instead, you should be using the [`StreamVideoService`](./StreamVideoService.md).
+     */
+    readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
+    private readonly writeableStateStore;
+    private callDropScheduler;
+    private coordinatorClient;
+    /**
+     * @internal
+     */
+    readonly userBatcher: Batcher<string>;
+    /**
+     * You should create only one instance of `StreamVideoClient`.
+     * @angular If you're using our Angular SDK, you shouldn't be calling the `constructor` directly, instead you should be using [`StreamVideoService`](./StreamVideoService.md/#init).
+     * @param apiKey your Stream API key
+     * @param opts the options for the client.
+     * @param {CallConfig} [callConfig=CALL_CONFIG.meeting] custom call configuration
+     */
+    constructor(apiKey: string, opts?: StreamClientOptions, callConfig?: CallConfig);
+    /**
+     * Connects the given user to the client.
+     * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.
+     * If the connection is successful, the connected user [state variable](#readonlystatestore) will be updated accordingly.
+     *
+     * @param user the user to connect.
+     * @param tokenOrProvider a token or a function that returns a token.
+     */
+    connectUser: (user: User, tokenOrProvider: TokenOrProvider) => Promise<void>;
+    /**
+     * Disconnects the currently connected user from the client.
+     *
+     * If the connection is successfully disconnected, the connected user [state variable](#readonlystatestore) will be updated accordingly
+     */
+    disconnectUser: () => Promise<void>;
+    /**
+     * You can subscribe to WebSocket events provided by the API.
+     * To remove a subscription, call the `off` method or, execute the returned unsubscribe function.
+     * Please note that subscribing to WebSocket events is an advanced use-case, for most use-cases it should be enough to watch for changes in the reactive [state store](#readonlystatestore).
+     *
+     * @param eventName the event name.
+     * @param callback the callback which will be called when the event is emitted.
+     * @returns an unsubscribe function.
+     */
+    on: (eventName: string, callback: EventHandler) => () => void;
+    /**
+     * Remove subscription for WebSocket events that were created by the `on` method.
+     *
+     * @param event the event name.
+     * @param callback the callback which was passed to the `on` method.
+     */
+    off: (event: string, callback: EventHandler) => void;
+    /**
+     * Allows you to create new calls with the given parameters.
+     * If a call with the same combination of type and id already exists, it will be returned.
+     *
+     * Causes the CallCreated event to be emitted to all the call members in case this call didnot exist before.
+     *
+     * @param id the id of the call.
+     * @param type the type of the call.
+     * @param data the data for the call.
+     * @returns A call metadata with information about the call.
+     */
+    getOrCreateCall: (id: string, type: string, data?: GetOrCreateCallRequest) => Promise<import("./gen/coordinator").GetOrCreateCallResponse | undefined>;
+    /**
+     * Signals other users that I have accepted the incoming call.
+     * Causes the `CallAccepted` event to be emitted to all the call members.
+     * @param callCid config ID of the rejected call
+     * @returns
+     */
+    acceptCall: (callCid: string) => Promise<Call | undefined>;
+    /**
+     * Signals other users that I have rejected the incoming call.
+     * Causes the `CallRejected` event to be emitted to all the call members.
+     * @param callCid config ID of the rejected call
+     * @returns
+     */
+    rejectCall: (callCid: string) => Promise<void>;
+    /**
+     * Signals other users that I have cancelled my call to them before they accepted it.
+     * Causes the CallCancelled event to be emitted to all the call members.
+     *
+     * Cancelling a call is only possible before the local participant joined the call.
+     * @param callCid config ID of the cancelled call
+     * @returns
+     */
+    cancelCall: (callCid: string) => Promise<void>;
+    /**
+     * Allows you to create a new call with the given parameters and joins the call immediately.
+     * If a call with the same combination of `type` and `id` already exists, it will join the existing call.
+     *
+     * @param id the id of the call.
+     * @param type the type of the call.
+     * @param data the data for the call.
+     * @returns A [`Call`](./Call.md) instance that can be used to interact with the call.
+     */
+    joinCall: (id: string, type: string, data?: GetOrCreateCallRequest) => Promise<Call | undefined>;
+    /**
+     * Starts recording for the call described by the given `callId` and `callType`.
+     * @param callId can be extracted from a [`Call` instance](./Call.md/#data)
+     * @param callType can be extracted from a [`Call` instance](./Call.md/#data)
+     */
+    startRecording: (callId: string, callType: string) => Promise<void>;
+    /**
+     * Stops recording for the call described by the given `callId` and `callType`.
+     * @param callId can be extracted from a [`Call` instance](./Call.md/#data)
+     * @param callType can be extracted from a [`Call` instance](./Call.md/#data)
+     */
+    stopRecording: (callId: string, callType: string) => Promise<void>;
+    /**
+     * Reports call WebRTC metrics to coordinator API
+     * @param stats
+     * @returns
+     */
+    private reportCallStats;
+    private getCallEdgeServer;
+    private toRtcConfiguration;
+    /**
+     * Reports call events (for example local participant muted themselves) to the coordinator API
+     * @param statEvent
+     * @returns
+     */
+    private reportCallStatEvent;
+    /**
+     * Sets the `participant.isPinned` value.
+     * @param sessionId the session id of the participant
+     * @param isPinned the value to set the participant.isPinned
+     * @returns
+     */
+    setParticipantIsPinned: (sessionId: string, isPinned: boolean) => void;
+}

package/dist/src/__tests__/StreamVideoClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/config/defaultConfigs.d.ts

@@ -0,0 +1,2 @@
+import { CallConfig, CallType } from './types';
+export declare const CALL_CONFIG: Record<CallType, CallConfig>;

package/dist/src/config/types.d.ts

@@ -0,0 +1,29 @@
+export type CallType = 'ring' | 'meeting';
+export type CallConfig = {
+    /**
+     * Optional parameter to define after how many milliseconds without receiving CallAccepted event should the outgoing call be cancelled.
+     * If not defined, the call will not be cancelled automatically by the client and the user is expected to cancel or leave the call manually.
+     * Note: Is relevant to outgoing calls only.
+     */
+    autoCancelTimeoutInMs?: number;
+    /**
+     * Optional parameter to define after how many milliseconds an incoming ring call should be automatically rejected.
+     * If not defined, the call will not be rejected automatically by the client and the user is expected to reject the call manually.
+     * Note: Is relevant to incoming calls only.
+     */
+    autoRejectTimeoutInMs?: number;
+    /**
+     * Optional parameter enabling automatic rejections of incoming calls while participating at an active call.
+     */
+    autoRejectWhenInCall?: boolean;
+    /**
+     * Flag signals to SDK components not to wait until CallAccepted event is received,
+     * but join the call immediately upon emitting a new PendingCall by the stateStore.
+     * Note: Is relevant to outgoing calls only. Once the caller joins an outgoing call it's not possible to cancel that call.
+     */
+    joinCallInstantly?: boolean;
+    /**
+     * Flag signals, whether sounds should be played upon initiation of a new call.
+     */
+    playSounds?: boolean;
+};

package/dist/src/coordinator/StreamCoordinatorClient.d.ts

@@ -0,0 +1,19 @@
+import { EventHandler, StreamClientOptions, TokenOrProvider, UR, User } from './connection/types';
+import { GetCallEdgeServerRequest, GetCallEdgeServerResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, JoinCallResponse, SendEventRequest } from '../gen/coordinator';
+export declare class StreamCoordinatorClient {
+    private client;
+    constructor(apiKey: string, options?: StreamClientOptions);
+    on: (callbackOrEventName: EventHandler | string, callbackOrNothing?: EventHandler) => () => void;
+    off: (callbackOrEventName: EventHandler | string, callbackOrNothing?: EventHandler) => void;
+    connectUser: (user: User, token: TokenOrProvider) => Promise<void | import("./connection/types").ConnectionOpen>;
+    disconnectUser: (timeout?: number) => Promise<void>;
+    getOrCreateCall: (id: string, type: string, data?: GetOrCreateCallRequest) => Promise<GetOrCreateCallResponse>;
+    joinCall: (id: string, type: string, data?: GetOrCreateCallRequest) => Promise<JoinCallResponse>;
+    getCallEdgeServer: (id: string, type: string, data: GetCallEdgeServerRequest) => Promise<GetCallEdgeServerResponse>;
+    queryUsers: () => Promise<void>;
+    sendEvent: (id: string, type: string, data: SendEventRequest) => Promise<unknown>;
+    startRecording: (id: string, type: string) => Promise<void>;
+    stopRecording: (id: string, type: string) => Promise<void>;
+    reportCallStats: (id: string, type: string, data: UR) => Promise<void>;
+    reportCallStatEvent: (id: string, type: string, data: UR) => Promise<void>;
+}

package/dist/src/coordinator/connection/base64.d.ts

@@ -0,0 +1,2 @@
+export declare const encodeBase64: (data: string) => string;
+export declare const decodeBase64: (s: string) => string;

package/dist/src/coordinator/connection/client.d.ts

@@ -0,0 +1,174 @@
+/// <reference types="node" />
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import WebSocket from 'isomorphic-ws';
+import { StableWSConnection } from './connection';
+import { TokenManager } from './token_manager';
+import { WSConnectionFallback } from './connection_fallback';
+import { APIErrorResponse, ConnectAPIResponse, ErrorFromResponse, Event, EventHandler, Logger, OwnUserResponse, StreamClientOptions, TokenOrProvider, UserResponse } from './types';
+import { InsightMetrics } from './insights';
+export declare class StreamClient {
+    _user?: OwnUserResponse | UserResponse;
+    anonymous: boolean;
+    persistUserOnConnectionFailure?: boolean;
+    axiosInstance: AxiosInstance;
+    baseURL?: string;
+    browser: boolean;
+    cleaningIntervalRef?: NodeJS.Timeout;
+    clientID?: string;
+    key: string;
+    listeners: Record<string, Array<(event: Event) => void>>;
+    logger: Logger;
+    node: boolean;
+    options: StreamClientOptions;
+    secret?: string;
+    setUserPromise: ConnectAPIResponse | null;
+    tokenManager: TokenManager;
+    user?: OwnUserResponse | UserResponse;
+    userAgent?: string;
+    userID?: string;
+    wsBaseURL?: string;
+    wsConnection: StableWSConnection | null;
+    wsFallback?: WSConnectionFallback;
+    wsPromise: ConnectAPIResponse | null;
+    consecutiveFailures: number;
+    insightMetrics: InsightMetrics;
+    defaultWSTimeoutWithFallback: number;
+    defaultWSTimeout: number;
+    private nextRequestAbortController;
+    /**
+     * Initialize a client.
+     *
+     * @param {string} key - the api key
+     * @param {string} [secret] - the api secret
+     * @param {StreamClientOptions} [options] - additional options, here you can pass custom options to axios instance
+     * @param {boolean} [options.browser] - enforce the client to be in browser mode
+     * @param {boolean} [options.warmUp] - default to false, if true, client will open a connection as soon as possible to speed up following requests
+     * @param {Logger} [options.Logger] - custom logger
+     * @param {number} [options.timeout] - default to 3000
+     * @param {httpsAgent} [options.httpsAgent] - custom httpsAgent, in node it's default to https.agent()
+     * @example <caption>initialize the client in user mode</caption>
+     * new StreamChat('api_key')
+     * @example <caption>initialize the client in user mode with options</caption>
+     * new StreamChat('api_key', { warmUp:true, timeout:5000 })
+     * @example <caption>secret is optional and only used in server side mode</caption>
+     * new StreamChat('api_key', "secret", { httpsAgent: customAgent })
+     */
+    constructor(key: string, options?: StreamClientOptions);
+    constructor(key: string, secret?: string, options?: StreamClientOptions);
+    devToken(userID: string): string;
+    getAuthType(): "anonymous" | "jwt";
+    setBaseURL(baseURL: string): void;
+    _getConnectionID: () => string | undefined;
+    _hasConnectionID: () => boolean;
+    /**
+     * connectUser - Set the current user and open a WebSocket connection
+     *
+     * @param {OwnUserResponse | UserResponse} user Data about this user. IE {name: "john"}
+     * @param {TokenOrProvider} userTokenOrProvider Token or provider
+     *
+     * @return {ConnectAPIResponse} Returns a promise that resolves when the connection is setup
+     */
+    connectUser: (user: OwnUserResponse | UserResponse, userTokenOrProvider: TokenOrProvider) => Promise<void | import("./types").ConnectionOpen>;
+    _setToken: (user: UserResponse, userTokenOrProvider: TokenOrProvider) => Promise<void>;
+    _setUser(user: OwnUserResponse | UserResponse): void;
+    /**
+     * Disconnects the websocket connection, without removing the user set on client.
+     * client.closeConnection will not trigger default auto-retry mechanism for reconnection. You need
+     * to call client.openConnection to reconnect to websocket.
+     *
+     * This is mainly useful on mobile side. You can only receive push notifications
+     * if you don't have active websocket connection.
+     * So when your app goes to background, you can call `client.closeConnection`.
+     * And when app comes back to foreground, call `client.openConnection`.
+     *
+     * @param timeout Max number of ms, to wait for close event of websocket, before forcefully assuming succesful disconnection.
+     *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
+     */
+    closeConnection: (timeout?: number) => Promise<void>;
+    /**
+     * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
+     */
+    openConnection: () => Promise<void | import("./types").ConnectionOpen>;
+    _normalizeDate: (before: Date | string | null) => string | null;
+    /**
+     * Disconnects the websocket and removes the user from client.
+     *
+     * @param timeout Max number of ms, to wait for close event of websocket, before forcefully assuming successful disconnection.
+     *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
+     */
+    disconnectUser: (timeout?: number) => Promise<void>;
+    /**
+     * connectAnonymousUser - Set an anonymous user and open a WebSocket connection
+     */
+    connectAnonymousUser: () => Promise<void | import("./types").ConnectionOpen>;
+    /**
+     * on - Listen to events on all channels and users your watching
+     *
+     * client.on('message.new', event => {console.log("my new message", event, channel.state.messages)})
+     * or
+     * client.on(event => {console.log(event.type)})
+     *
+     * @param {EventHandler | string} callbackOrEventName  The event type to listen for (optional)
+     * @param {EventHandler} [callbackOrNothing] The callback to call
+     *
+     * @return {Function} Returns a function which, when called, unsubscribes the event handler.
+     */
+    on(callbackOrEventName: EventHandler | string, callbackOrNothing?: EventHandler): () => void;
+    /**
+     * off - Remove the event handler
+     *
+     */
+    off(callbackOrEventName: EventHandler | string, callbackOrNothing?: EventHandler): void;
+    _logApiRequest(type: string, url: string, data: unknown, config: AxiosRequestConfig & {
+        config?: AxiosRequestConfig & {
+            maxBodyLength?: number;
+        };
+    }): void;
+    _logApiResponse<T>(type: string, url: string, response: AxiosResponse<T>): void;
+    _logApiError(type: string, url: string, error: unknown): void;
+    doAxiosRequest: <T>(type: string, url: string, data?: unknown, options?: AxiosRequestConfig & {
+        config?: AxiosRequestConfig & {
+            maxBodyLength?: number;
+        };
+    }) => Promise<T>;
+    get<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    put<T>(url: string, data?: unknown): Promise<T>;
+    post<T>(url: string, data?: unknown): Promise<T>;
+    patch<T>(url: string, data?: unknown): Promise<T>;
+    delete<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    errorFromResponse(response: AxiosResponse<APIErrorResponse>): ErrorFromResponse<APIErrorResponse>;
+    handleResponse<T>(response: AxiosResponse<T>): T;
+    dispatchEvent: (event: Event) => void;
+    handleEvent: (messageEvent: WebSocket.MessageEvent) => void;
+    _callClientListeners: (event: Event) => void;
+    /**
+     * @private
+     */
+    connect(): Promise<void | import("./types").ConnectionOpen>;
+    /**
+     * Check the connectivity with server for warmup purpose.
+     *
+     * @private
+     */
+    _sayHi(): void;
+    getUserAgent(): string;
+    setUserAgent(userAgent: string): void;
+    /**
+     * _isUsingServerAuth - Returns true if we're using server side auth
+     */
+    _isUsingServerAuth: () => boolean;
+    _enrichAxiosOptions(options?: AxiosRequestConfig & {
+        config?: AxiosRequestConfig;
+    }): AxiosRequestConfig;
+    _getToken(): string | null | undefined;
+    /**
+     * encode ws url payload
+     * @private
+     * @returns json string
+     */
+    _buildWSPayload: (client_request_id?: string) => string;
+    /**
+     * creates an abort controller that will be used by the next HTTP Request.
+     */
+    createAbortControllerForNextRequest(): AbortController;
+}

package/dist/src/coordinator/connection/connection.d.ts

@@ -0,0 +1,139 @@
+/// <reference types="node" />
+/// <reference types="ws" />
+import WebSocket from 'isomorphic-ws';
+import { StreamClient } from './client';
+import type { ConnectAPIResponse, ConnectionOpen, LogLevel, UR } from './types';
+/**
+ * StableWSConnection - A WS connection that reconnects upon failure.
+ * - the browser will sometimes report that you're online or offline
+ * - the WS connection can break and fail (there is a 30s health check)
+ * - sometimes your WS connection will seem to work while the user is in fact offline
+ * - to speed up online/offline detection you can use the window.addEventListener('offline');
+ *
+ * There are 4 ways in which a connection can become unhealthy:
+ * - websocket.onerror is called
+ * - websocket.onclose is called
+ * - the health check fails and no event is received for ~40 seconds
+ * - the browser indicates the connection is now offline
+ *
+ * There are 2 assumptions we make about the server:
+ * - state can be recovered by querying the channel again
+ * - if the servers fails to publish a message to the client, the WS connection is destroyed
+ */
+export declare class StableWSConnection {
+    connectionID?: string;
+    connectionOpen?: ConnectAPIResponse;
+    consecutiveFailures: number;
+    pingInterval: number;
+    healthCheckTimeoutRef?: NodeJS.Timeout;
+    isConnecting: boolean;
+    isDisconnected: boolean;
+    isHealthy: boolean;
+    isResolved?: boolean;
+    lastEvent: Date | null;
+    connectionCheckTimeout: number;
+    connectionCheckTimeoutRef?: NodeJS.Timeout;
+    rejectPromise?: (reason?: Error & {
+        code?: string | number;
+        isWSFailure?: boolean;
+        StatusCode?: string | number;
+    }) => void;
+    requestID: string | undefined;
+    resolvePromise?: (value: ConnectionOpen) => void;
+    totalFailures: number;
+    ws?: WebSocket;
+    wsID: number;
+    token: string;
+    client: StreamClient;
+    constructor(client: StreamClient);
+    _log(msg: string, extra?: UR, level?: LogLevel): void;
+    setClient: (client: StreamClient) => void;
+    /**
+     * connect - Connect to the WS URL
+     * the default 15s timeout allows between 2~3 tries
+     * @return {ConnectAPIResponse<ChannelType, CommandType, UserType>} Promise that completes once the first health check message is received
+     */
+    connect(timeout?: number): Promise<void | ConnectionOpen>;
+    /**
+     * _waitForHealthy polls the promise connection to see if its resolved until it times out
+     * the default 15s timeout allows between 2~3 tries
+     * @param timeout duration(ms)
+     */
+    _waitForHealthy(timeout?: number): Promise<void | ConnectionOpen>;
+    /**
+     * Builds and returns the url for websocket.
+     * @private
+     * @returns url string
+     */
+    _buildUrl: () => string;
+    /**
+     * disconnect - Disconnect the connection and doesn't recover...
+     *
+     */
+    disconnect(timeout?: number): Promise<void>;
+    /**
+     * _connect - Connect to the WS endpoint
+     *
+     * @return {ConnectAPIResponse<ChannelType, CommandType, UserType>} Promise that completes once the first health check message is received
+     */
+    _connect(): Promise<ConnectionOpen | undefined>;
+    /**
+     * _reconnect - Retry the connection to WS endpoint
+     *
+     * @param {{ interval?: number; refreshToken?: boolean }} options Following options are available
+     *
+     * - `interval`	{int}			number of ms that function should wait before reconnecting
+     * - `refreshToken` {boolean}	reload/refresh user token be refreshed before attempting reconnection.
+     */
+    _reconnect(options?: {
+        interval?: number;
+        refreshToken?: boolean;
+    }): Promise<void>;
+    /**
+     * onlineStatusChanged - this function is called when the browser connects or disconnects from the internet.
+     *
+     * @param {Event} event Event with type online or offline
+     *
+     */
+    onlineStatusChanged: (event: Event) => void;
+    onopen: (wsID: number) => void;
+    onmessage: (wsID: number, event: WebSocket.MessageEvent) => void;
+    onclose: (wsID: number, event: WebSocket.CloseEvent) => void;
+    onerror: (wsID: number, event: WebSocket.ErrorEvent) => void;
+    /**
+     * _setHealth - Sets the connection to healthy or unhealthy.
+     * Broadcasts an event in case the connection status changed.
+     *
+     * @param {boolean} healthy boolean indicating if the connection is healthy or not
+     *
+     */
+    _setHealth: (healthy: boolean) => void;
+    /**
+     * _errorFromWSEvent - Creates an error object for the WS event
+     *
+     */
+    _errorFromWSEvent: (event: WebSocket.CloseEvent | WebSocket.Data | WebSocket.ErrorEvent, isWSFailure?: boolean) => Error & {
+        code?: string | number | undefined;
+        isWSFailure?: boolean | undefined;
+        StatusCode?: string | number | undefined;
+    };
+    /**
+     * _destroyCurrentWSConnection - Removes the current WS connection
+     *
+     */
+    _destroyCurrentWSConnection(): void;
+    /**
+     * _setupPromise - sets up the this.connectOpen promise
+     */
+    _setupConnectionPromise: () => void;
+    /**
+     * Schedules a next health check ping for websocket.
+     */
+    scheduleNextPing: () => void;
+    /**
+     * scheduleConnectionCheck - schedules a check for time difference between last received event and now.
+     * If the difference is more than 35 seconds, it means our health check logic has failed and websocket needs
+     * to be reconnected.
+     */
+    scheduleConnectionCheck: () => void;
+}

package/dist/src/coordinator/connection/connection_fallback.d.ts

@@ -0,0 +1,38 @@
+import { AxiosRequestConfig, CancelTokenSource } from 'axios';
+import { StreamClient } from './client';
+import { ConnectionOpen, UR, LogLevel } from './types';
+export declare enum ConnectionState {
+    Closed = "CLOSED",
+    Connected = "CONNECTED",
+    Connecting = "CONNECTING",
+    Disconnected = "DISCONNECTED",
+    Init = "INIT"
+}
+export declare class WSConnectionFallback {
+    client: StreamClient;
+    state: ConnectionState;
+    consecutiveFailures: number;
+    connectionID?: string;
+    cancelToken?: CancelTokenSource;
+    constructor(client: StreamClient);
+    _log(msg: string, extra?: UR, level?: LogLevel): void;
+    _setState(state: ConnectionState): void;
+    /** @private */
+    _onlineStatusChanged: (event: {
+        type: string;
+    }) => void;
+    /** @private */
+    _req: <T = UR>(params: UR, config: AxiosRequestConfig, retry: boolean) => Promise<T>;
+    /** @private */
+    _poll: () => Promise<void>;
+    /**
+     * connect try to open a longpoll request
+     * @param reconnect should be false for first call and true for subsequent calls to keep the connection alive and call recoverState
+     */
+    connect: (reconnect?: boolean) => Promise<ConnectionOpen | undefined>;
+    /**
+     * isHealthy checks if there is a connectionID and connection is in Connected state
+     */
+    isHealthy: () => boolean;
+    disconnect: (timeout?: number) => Promise<void>;
+}

package/dist/src/coordinator/connection/errors.d.ts

@@ -0,0 +1,16 @@
+import { AxiosResponse } from 'axios';
+import { APIErrorResponse } from './types';
+export declare const APIErrorCodes: Record<string, {
+    name: string;
+    retryable: boolean;
+}>;
+type APIError = Error & {
+    code: number;
+    isWSFailure?: boolean;
+};
+export declare function isAPIError(error: Error): error is APIError;
+export declare function isErrorRetryable(error: APIError): boolean;
+export declare function isConnectionIDError(error: APIError): boolean;
+export declare function isWSFailure(err: APIError): boolean;
+export declare function isErrorResponse(res: AxiosResponse<unknown>): res is AxiosResponse<APIErrorResponse>;
+export {};