@webex/contact-center 3.11.0 → 3.12.0

package/dist/types/services/constants.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Post-authentication event name.
+ * @type {string}
+ * @public
+ * @example
+ * if (event === POST_AUTH) { ... }
+ * @ignore
+ */
+export declare const POST_AUTH = "postauth";
+/**
+ * API gateway identifier for Webex Contact Center.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const WCC_API_GATEWAY = "wcc-api-gateway";
+/**
+ * Domain identifier for WCC Calling RTMS.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const WCC_CALLING_RTMS_DOMAIN = "wcc-calling-rtms-domain";
+/**
+ * Default RTMS domain for production use.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const DEFAULT_RTMS_DOMAIN = "rtw.prod-us1.rtmsprod.net";
+/**
+ * Timeout in milliseconds for WebSocket events.
+ * @type {number}
+ * @public
+ * @example
+ * setTimeout(() => { ... }, WEBSOCKET_EVENT_TIMEOUT);
+ * @ignore
+ */
+export declare const WEBSOCKET_EVENT_TIMEOUT = 20000;
+/**
+ * Agent role identifier.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const AGENT = "agent";
+/**
+ * API path for notification subscription.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const SUBSCRIBE_API = "v1/notification/subscribe";
+/**
+ * API path for agent login.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const LOGIN_API = "v1/agents/login";
+/**
+ * Prefix for WebRTC-related API endpoints.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const WEB_RTC_PREFIX = "webrtc-";
+/**
+ * API path for agent session state changes.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const STATE_CHANGE_API = "v1/agents/session/state";
+/**
+ * Message for deregistering WebCalling line and cleaning up resources.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export declare const DEREGISTER_WEBCALLING_LINE_MSG = "Deregistering WebCalling line and cleaning up resources";
+export declare const METHODS: {
+    SET_LOGIN_OPTION: string;
+    HANDLE_MEDIA_EVENT: string;
+    HANDLE_DISCONNECT_EVENT: string;
+    REGISTER_CALL_LISTENERS: string;
+    CLEAN_UP_CALL: string;
+    GET_RTMS_DOMAIN: string;
+    REGISTER_WEB_CALLING_LINE: string;
+    DEREGISTER_WEB_CALLING_LINE: string;
+    ANSWER_CALL: string;
+    MUTE_UNMUTE_CALL: string;
+    IS_CALL_MUTED: string;
+    DECLINE_CALL: string;
+    MAP_CALL_TO_TASK: string;
+    GET_TASK_ID_FOR_CALL: string;
+};
+export declare const AI_ASSISTANT_API_URLS: {
+    EVENT: string;
+    TRANSCRIPTS_LIST: string;
+};
+export declare const AI_ASSISTANT_BASE_URL_TEMPLATE = "https://api-ai-assistant.%s.ciscoccservice.com";
+export declare const AI_ASSISTANT_ENV_MAP: Record<string, string>;

package/dist/types/services/core/Err.d.ts

@@ -0,0 +1,121 @@
+import { WebexRequestPayload } from '../../types';
+import { Failure } from './GlobalTypes';
+/**
+ * Err module provides a structured way to handle errors in the Contact Center plugin.
+ * @ignore
+ */
+export type ErrDetails = {
+    status: number;
+    type: string;
+    trackingId: string;
+};
+export type AgentErrorIds = {
+    'Service.aqm.agent.stationLogin': ErrDetails;
+} | {
+    'Service.aqm.agent.stationLoginFailed': Failure;
+} | {
+    'Service.aqm.agent.stateChange': Failure;
+} | {
+    'Service.aqm.agent.reload': Failure;
+} | {
+    'Service.aqm.agent.logout': Failure;
+} | {
+    'Service.reqs.generic.failure': {
+        trackingId: string;
+    };
+} | {
+    'Service.aqm.agent.BuddyAgentsRetrieveFailed': Failure;
+};
+export type vteamType = 'inboundqueue' | 'inboundentrypoint' | string;
+export type TaskErrorIds = {
+    'Service.aqm.task.accept': Failure;
+} | {
+    'Service.aqm.task.end': Failure;
+} | {
+    'Service.aqm.task.wrapup': Failure;
+} | {
+    'Service.aqm.task.AgentVteamTransferFailed': Failure;
+} | {
+    'Service.aqm.task.AgentBlindTransferFailedEvent': Failure;
+} | {
+    'Service.aqm.task.AgentConsultTransferFailed': Failure;
+} | {
+    'Service.aqm.task.consult': Failure;
+} | {
+    'Service.aqm.err.trackingId': {
+        trackingId: string;
+    };
+} | {
+    'Service.aqm.task.consultAccept': Failure;
+} | {
+    'Service.aqm.task.consultConference': Failure;
+} | {
+    'Service.aqm.task.consultEnd': Failure;
+} | {
+    'Service.aqm.task.cancelCtq': Failure;
+} | {
+    'Service.aqm.task.hold': Failure;
+} | {
+    'Service.aqm.task.unHold': Failure;
+} | {
+    'Service.aqm.task.VteamListFailed': Failure;
+} | {
+    'Service.aqm.task.pauseRecording': Failure;
+} | {
+    'Service.aqm.task.resumeRecording': Failure;
+} | {
+    'Service.aqm.dialer.startOutdial': Failure;
+} | {
+    'Service.aqm.dialer.acceptPreviewContact': Failure;
+} | {
+    'Service.reqs.generic.failure': {
+        trackingId: string;
+    };
+};
+export type ReqError = 'Service.aqm.reqs.GenericRequestError' | {
+    'Service.aqm.reqs.Pending': {
+        key: string;
+        msg: string;
+    };
+} | {
+    'Service.aqm.reqs.PendingEvent': {
+        key: string;
+    };
+} | {
+    'Service.aqm.reqs.Timeout': {
+        key: string;
+        response: WebexRequestPayload;
+    };
+} | {
+    'Service.aqm.reqs.TimeoutEvent': {
+        key: string;
+    };
+};
+export interface Ids {
+    'Service.aqm.agent': AgentErrorIds;
+    'Service.aqm.reqs': ReqError;
+    'Service.aqm.task': TaskErrorIds;
+}
+export type IdsGlobal = 'system' | 'handle' | 'fallback';
+export type IdsSub = Ids[keyof Ids];
+export type IdsMessage = IdsGlobal | keyof Ids | Exclude<IdsSub, object>;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type FlattenUnion<T> = {
+    [K in keyof UnionToIntersection<T>]: K extends keyof T ? T[K] extends any[] ? T[K] : T[K] extends object ? FlattenUnion<T[K]> : T[K] : UnionToIntersection<T>[K];
+};
+export type IdsDetailsType = FlattenUnion<Exclude<IdsSub, string>>;
+export type IdsDetails = keyof IdsDetailsType;
+export type Id = IdsMessage | IdsDetails;
+export declare class Message extends Error {
+    readonly id: Id;
+    constructor(id: IdsMessage);
+    constructor(id: IdsMessage, message: string);
+    constructor(id: IdsMessage, errror: Error);
+    private isErr;
+}
+export declare class Details<T extends IdsDetails> extends Error {
+    readonly id: Id;
+    readonly details: IdsDetailsType[T];
+    constructor(id: T, details: IdsDetailsType[T]);
+    private isErr;
+}

package/dist/types/services/core/GlobalTypes.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Generic message interface used throughout the plugin
+ * @template T - Type of the data payload (defaults to any)
+ * @private
+ * @ignore
+ */
+export type Msg<T = any> = {
+    /** Message/Event type identifier */
+    type: string;
+    /** Organization identifier */
+    orgId: string;
+    /** Unique tracking identifier for the message/Event */
+    trackingId: string;
+    /** Message/Event payload data */
+    data: T;
+};
+/**
+ * Represents a failure message with specific error details
+ * @private
+ * @ignore
+ */
+export type Failure = Msg<{
+    /** Agent identifier associated with the failure */
+    agentId: string;
+    /** Tracking identifier for the failure event */
+    trackingId: string;
+    /** Numeric code indicating the reason for failure */
+    reasonCode: number;
+    /** Organization identifier */
+    orgId: string;
+    /** Human-readable description of the failure reason */
+    reason: string;
+}>;
+/**
+ * Represents task API error details in a structured format
+ * @public
+ */
+export interface TaskError {
+    /** Original error object for throwing */
+    error: Error;
+    /** Unique tracking identifier for correlation */
+    trackingId: string;
+    /** Detailed error message from the API */
+    errorMessage: string;
+    /** Type/category of the error (e.g., "Bad Request") */
+    errorType: string;
+    /** Additional error context data */
+    errorData: string;
+    /** Numeric reason code */
+    reasonCode: number;
+}
+/**
+ * An Error object augmented with a flexible data field for additional context.
+ * Use this to attach structured data to thrown errors without ts-ignore.
+ */
+export interface AugmentedError extends Error {
+    data?: Record<string, any>;
+}

package/dist/types/services/core/Utils.d.ts

@@ -0,0 +1,101 @@
+import * as Err from './Err';
+import { LoginOption, WebexRequestPayload } from '../../types';
+import { Failure, AugmentedError } from './GlobalTypes';
+import { TaskData, ConsultTransferPayLoad, Interaction } from '../task/types';
+import { DialPlan } from '../config/types';
+export declare const FALLBACK_DIAL_NUMBER_REGEX: RegExp;
+/**
+ * Validates a dial number against the provided dial plan regex patterns.
+ * A number is valid if it matches at least one regex pattern in the dial plans.
+ * Falls back to US/Canada regex validation if no dial plan entries are configured.
+ *
+ * @param input - The dial number to validate
+ * @param dialPlanEntries - Array of dial plan entries containing regex patterns
+ * @returns true if the input matches at least one dial plan regex pattern, false otherwise
+ */
+export declare const isValidDialNumber: (input: string, dialPlanEntries: DialPlan['dialPlanEntity']) => boolean;
+export declare const getStationLoginErrorData: (failure: Failure, loginOption: LoginOption) => {
+    message: any;
+    fieldName: any;
+};
+/**
+ * Extracts error details and logs the error. Also uploads logs for the error unless it is a silent relogin agent not found error.
+ *
+ * @param error - The error object, expected to have a `details` property of type Failure.
+ * @param methodName - The name of the method where the error occurred.
+ * @param moduleName - The name of the module where the error occurred.
+ * @returns An object containing the error instance and the reason string.
+ * @public
+ * @example
+ * const details = getErrorDetails(error, 'fetchData', 'DataModule');
+ * if (details.error) { handleError(details.error); }
+ * @ignore
+ */
+export declare const getErrorDetails: (error: any, methodName: string, moduleName: string) => {
+    error: Error;
+    reason: string;
+};
+/**
+ * Extracts error details from task API errors and logs them. Also uploads logs for the error.
+ * This handles the specific error format returned by task API calls.
+ *
+ * @param error - The error object from task API calls with structure: {id: string, details: {trackingId: string, msg: {...}}}
+ * @param methodName - The name of the method where the error occurred.
+ * @param moduleName - The name of the module where the error occurred.
+ * @returns AugmentedError containing structured error details on err.data for metrics and logging
+ * @public
+ * @example
+ * const taskError = generateTaskErrorObject(error, 'transfer', 'TaskModule');
+ * throw taskError.error;
+ * @ignore
+ */
+export declare const generateTaskErrorObject: (error: any, methodName: string, moduleName: string) => AugmentedError;
+/**
+ * Creates an error details object suitable for use with the Err.Details class.
+ *
+ * @param errObj - The Webex request payload object.
+ * @returns An instance of Err.Details with the generic failure message and extracted details.
+ * @public
+ * @example
+ * const errDetails = createErrDetailsObject(webexRequestPayload);
+ * @ignore
+ */
+export declare const createErrDetailsObject: (errObj: WebexRequestPayload) => Err.Details<"Service.reqs.generic.failure">;
+/**
+ * Gets the consulted agent ID from the media object by finding the agent
+ * in the consult media participants (excluding the current agent).
+ *
+ * @param media - The media object from the interaction
+ * @param agentId - The current agent's ID to exclude from the search
+ * @returns The consulted agent ID, or empty string if none found
+ */
+export declare const getConsultedAgentId: (media: Interaction['media'], agentId: string) => string;
+/**
+ * Gets the destination agent ID for CBT (Capacity Based Team) scenarios.
+ * CBT refers to teams created in Control Hub with capacity-based routing
+ * (as opposed to agent-based routing). This handles cases where the consulted
+ * participant is not directly in participants but can be found by matching
+ * the dial number (dn).
+ *
+ * @param interaction - The interaction object
+ * @param consultingAgent - The consulting agent identifier
+ * @returns The destination agent ID for CBT scenarios, or empty string if none found
+ */
+export declare const getDestAgentIdForCBT: (interaction: Interaction, consultingAgent: string) => string;
+/**
+ * Calculates the destination agent ID for consult operations.
+ *
+ * @param interaction - The interaction object
+ * @param agentId - The current agent's ID
+ * @returns The destination agent ID
+ */
+export declare const calculateDestAgentId: (interaction: Interaction, agentId: string) => string;
+/**
+ * Calculates the destination agent ID for fetching destination type.
+ *
+ * @param interaction - The interaction object
+ * @param agentId - The current agent's ID
+ * @returns The destination agent ID for determining destination type
+ */
+export declare const calculateDestType: (interaction: Interaction, agentId: string) => string;
+export declare const deriveConsultTransferDestinationType: (taskData?: TaskData) => ConsultTransferPayLoad['destinationType'];

package/dist/types/services/core/WebexRequest.d.ts

@@ -0,0 +1,22 @@
+import { WebexSDK, HTTP_METHODS, IHttpResponse, RequestBody, UploadLogsResponse, LogsMetaData } from '../../types';
+declare class WebexRequest {
+    private webex;
+    private static instance;
+    static getInstance(options?: {
+        webex: WebexSDK;
+    }): WebexRequest;
+    private constructor();
+    request(options: {
+        service: string;
+        resource: string;
+        method: HTTP_METHODS;
+        body?: RequestBody;
+    }): Promise<IHttpResponse>;
+    /**
+     * This is used for uploading the logs to backend/mats.
+     *
+     * @param metaData - meta data to be uploaded.
+     */
+    uploadLogs(metaData?: LogsMetaData): Promise<UploadLogsResponse>;
+}
+export default WebexRequest;

package/dist/types/services/core/aqm-reqs.d.ts

@@ -0,0 +1,65 @@
+import { Conf, ConfEmpty, Res, ResEmpty } from './types';
+import { WebSocketManager } from './websocket/WebSocketManager';
+export default class AqmReqs {
+    private pendingRequests;
+    private pendingNotifCancelrequest;
+    private webexRequest;
+    private webSocketManager;
+    constructor(webSocketManager: WebSocketManager);
+    /**
+     * Creates a request function for an API call with parameters
+     * @param c - The configuration for the request
+     * @returns A function that makes the API request
+     */
+    req<TRes, TErr, TReq>(c: Conf<TRes, TErr, TReq>): Res<TRes, TReq>;
+    /**
+     * Creates a request function for an API call with no parameters
+     * @param c - The configuration for the request
+     * @returns A function that makes the API request
+     */
+    reqEmpty<TRes, TErr>(c: ConfEmpty<TRes, TErr>): ResEmpty<TRes>;
+    /**
+     * Makes an API request
+     * @param c - The request configuration
+     * @param cbRes - The callback for the response
+     * @returns A promise that resolves with the response or rejects with an error
+     */
+    private makeAPIRequest;
+    /**
+     * Creates a promise for an API request
+     * @param c - The request configuration
+     * @param cbRes - The callback for the response
+     * @returns A promise that resolves with the response or rejects with an error
+     */
+    private createPromise;
+    /**
+     * Converts a bind object to a string representation
+     * @param bind - The bind object to convert
+     * @returns A string representation of the bind object
+     */
+    private bindPrint;
+    /**
+     * Checks if a message matches a bind object
+     * @param bind - The bind object to check against
+     * @param msg - The message to check
+     * @returns True if the message matches the bind object, false otherwise
+     */
+    private bindCheck;
+    /**
+     * Checks type-dependent field conditions defined in __typeMap.
+     * @param typeMap - The type map to check against
+     * @param msg - The message to check
+     * @returns True if the message matches the type map, false otherwise
+     * The typeMap has the shape:
+     *   { typeField: "type", conditions: { EventA: { field: value }, EventB: { field: value } } }
+     * It reads msg[typeField] to determine which condition set to apply,
+     * then verifies all fields in that condition match the message.
+     */
+    private static typeMapCheck;
+    /**
+     * Handles incoming messages from the WebSocket (must be a lambda fn)
+     * @param msg - The message to handle
+     * @returns
+     */
+    private readonly onMessage;
+}

package/dist/types/services/core/constants.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Interval in milliseconds for sending keepalive pings to the worker.
+ * @ignore
+ */
+export declare const KEEPALIVE_WORKER_INTERVAL = 4000;
+/**
+ * Delay in milliseconds before resolving notification handlers.
+ * @ignore
+ */
+export declare const NOTIFS_RESOLVE_DELAY = 1200;
+/**
+ * Timeout duration in milliseconds before forcefully closing a WebSocket connection.
+ * @ignore
+ */
+export declare const CLOSE_SOCKET_TIMEOUT_DURATION = 16000;
+/**
+ * API endpoint used for connectivity or health checks.
+ * @ignore
+ */
+export declare const PING_API_URL = "/health";
+/**
+ * Timeout in milliseconds to wait for a welcome message after socket connection.
+ * @ignore
+ */
+export declare const WELCOME_TIMEOUT = 30000;
+/**
+ * Event name used for real-time device (RTD) ping status.
+ * @ignore
+ */
+export declare const RTD_PING_EVENT = "rtd-online-status";
+/**
+ * Timeout in milliseconds for individual HTTP requests.
+ * @ignore
+ */
+export declare const TIMEOUT_REQ = 20000;
+/**
+ * Duration in milliseconds to wait before attempting lost connection recovery.
+ * @ignore
+ */
+export declare const LOST_CONNECTION_RECOVERY_TIMEOUT = 50000;
+/**
+ * Duration in milliseconds after which a WebSocket disconnect is considered allowed or expected.
+ * @ignore
+ */
+export declare const WS_DISCONNECT_ALLOWED = 8000;
+/**
+ * Interval in milliseconds to check for connectivity status.
+ * @ignore
+ */
+export declare const CONNECTIVITY_CHECK_INTERVAL = 5000;
+/**
+ * Timeout in milliseconds for cleanly closing the WebSocket.
+ * @ignore
+ */
+export declare const CLOSE_SOCKET_TIMEOUT = 16000;
+/**
+ * Constants for participant types, destination types, and interaction states
+ * @ignore
+ */
+export declare const PARTICIPANT_TYPES: {
+    /** Participant type for Entry Point Dial Number */
+    EP_DN: string;
+    /** Participant type for dial number */
+    DN: string;
+    /** Participant type for Agent */
+    AGENT: string;
+};
+/** Interaction state for consultation */
+export declare const STATE_CONSULT = "consult";
+export declare const METHODS: {
+    REQUEST: string;
+    UPLOAD_LOGS: string;
+    GET_ERROR_DETAILS: string;
+    GET_COMMON_ERROR_DETAILS: string;
+    CREATE_ERR_DETAILS_OBJECT: string;
+    REQ: string;
+    REQ_EMPTY: string;
+    MAKE_API_REQUEST: string;
+    CREATE_PROMISE: string;
+    BIND_PRINT: string;
+    BIND_CHECK: string;
+    ON_MESSAGE: string;
+    INIT_WEB_SOCKET: string;
+    CLOSE: string;
+    HANDLE_CONNECTION_LOST: string;
+    REGISTER: string;
+    CONNECT: string;
+    WEB_SOCKET_ON_CLOSE_HANDLER: string;
+    SETUP_EVENT_LISTENERS: string;
+    DISPATCH_CONNECTION_EVENT: string;
+    CS_HANDLE_CONNECTION_LOST: string;
+    CLEAR_TIMER_ON_RESTORE_FAILED: string;
+    HANDLE_RESTORE_FAILED: string;
+    UPDATE_CONNECTION_DATA: string;
+    SET_CONNECTION_PROP: string;
+    ON_PING: string;
+    HANDLE_SOCKET_CLOSE: string;
+    ON_SOCKET_CLOSE: string;
+};

package/dist/types/services/core/types.d.ts

@@ -0,0 +1,47 @@
+import { HTTP_METHODS, RequestBody, WebexRequestPayload } from '../../types';
+import * as Err from './Err';
+import { Msg } from './GlobalTypes';
+export type Pending = {
+    check: (msg: Msg) => boolean;
+    handle: (msg: Msg) => void;
+    alternateBind?: string;
+};
+export type BindType = string | string[] | {
+    [key: string]: BindType;
+};
+interface Bind {
+    type: BindType;
+    data?: any;
+}
+export type Timeout = number | 'disabled';
+export type Req<TRes, TErr> = {
+    url: string;
+    host?: string;
+    method?: HTTP_METHODS;
+    err?: ((errObj: WebexRequestPayload) => Err.Details<'Service.reqs.generic.failure'>) | Err.IdsMessage | ((e: WebexRequestPayload) => Err.Message | Err.Details<Err.IdsDetails>);
+    notifSuccess: {
+        bind: Bind;
+        msg: TRes;
+    };
+    notifFail?: {
+        bind: Bind;
+        errMsg: TErr;
+        err: (e: TErr) => Err.Details<Err.IdsDetails>;
+    } | {
+        bind: Bind;
+        errId: Err.IdsDetails;
+    };
+    data?: RequestBody;
+    headers?: Record<string, string>;
+    timeout?: Timeout;
+    notifCancel?: {
+        bind: Bind;
+        msg: TRes;
+    };
+};
+export type Conf<TRes, TErr, TReq> = (p: TReq) => Req<TRes, TErr>;
+export type ConfEmpty<TRes, TErr> = () => Req<TRes, TErr>;
+export type Res<TRes, TReq> = (p: TReq, cbRes?: CbRes<TRes>) => Promise<TRes>;
+export type ResEmpty<TRes> = (cbRes?: CbRes<TRes>) => Promise<TRes>;
+export type CbRes<TRes> = (res: any) => void | TRes;
+export {};

package/dist/types/services/core/websocket/WebSocketManager.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { WebexSDK, SubscribeRequest } from '../../../types';
+import { ConnectionLostDetails } from './types';
+import { WelcomeResponse } from '../../config/types';
+/**
+ * WebSocketManager handles the WebSocket connection for Contact Center operations.
+ * It manages the connection lifecycle, including registration, reconnection, and message handling.
+ * It also utilizes a Web Worker to manage keepalive messages and socket closure.
+ * @ignore
+ */
+export declare class WebSocketManager extends EventEmitter {
+    private websocket;
+    shouldReconnect: boolean;
+    isSocketClosed: boolean;
+    private isWelcomeReceived;
+    private url;
+    private forceCloseWebSocketOnTimeout;
+    private isConnectionLost;
+    private webex;
+    private welcomePromiseResolve;
+    private keepaliveWorker;
+    constructor(options: {
+        webex: WebexSDK;
+    });
+    initWebSocket(options: {
+        body: SubscribeRequest;
+    }): Promise<WelcomeResponse>;
+    close(shouldReconnect: boolean, reason?: string): void;
+    handleConnectionLost(event: ConnectionLostDetails): void;
+    private register;
+    private connect;
+    private webSocketOnCloseHandler;
+}

package/dist/types/services/core/websocket/connection-service.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { ConnectionServiceOptions, ConnectionProp } from './types';
+export declare class ConnectionService extends EventEmitter {
+    private connectionProp;
+    private wsDisconnectAllowed;
+    private reconnectingTimer;
+    private restoreTimer;
+    private isConnectionLost;
+    private isRestoreFailed;
+    private isSocketReconnected;
+    private isKeepAlive;
+    private reconnectInterval;
+    private webSocketManager;
+    private subscribeRequest;
+    constructor(options: ConnectionServiceOptions);
+    private setupEventListeners;
+    private dispatchConnectionEvent;
+    private handleConnectionLost;
+    private clearTimerOnRestoreFailed;
+    private handleRestoreFailed;
+    private updateConnectionData;
+    setConnectionProp(prop: ConnectionProp): void;
+    private onPing;
+    private handleSocketClose;
+    private onSocketClose;
+}

package/dist/types/services/core/websocket/keepalive.worker.d.ts

@@ -0,0 +1,2 @@
+export default workerScript;
+declare const workerScript: "\nconsole.log(\"*** Keepalive Worker Thread ***\");\nlet intervalId, intervalDuration, timeOutId, isSocketClosed, closeSocketTimeout;\nlet initialised = false;\nlet initiateWebSocketClosure = false;\n\nconst resetOfflineHandler = function () {\n  if (timeOutId) {\n    initialised = false;\n    clearTimeout(timeOutId);\n    timeOutId = null;\n  }\n};\n\nconst checkOnlineStatus = function () {\n  const onlineStatus = navigator.onLine;\n  console.log(\n    `[WebSocketStatus] event=checkOnlineStatus | online status=`,\n    onlineStatus\n  );\n  return onlineStatus;\n};\n\n// Checks network status and if it's offline then force closes WebSocket\nconst checkNetworkStatus = function () {\n  const onlineStatus = checkOnlineStatus();\n  postMessage({ type: \"keepalive\", onlineStatus });\n  if (!onlineStatus && !initialised) {\n    initialised = true;\n    // Sets a timeout of 16s, checks if socket didn't close then it closes forcefully\n    timeOutId = setTimeout(() => {\n      if (!isSocketClosed) {\n        initiateWebSocketClosure = true;\n        postMessage({ type: \"closeSocket\" });\n      }\n    }, closeSocketTimeout);\n  }\n\n  if (onlineStatus && initialised) {\n    initialised = false;\n  }\n\n  if (initiateWebSocketClosure) {\n    initiateWebSocketClosure = false;\n    clearTimeout(timeOutId);\n    timeOutId = null;\n  }\n};\n\naddEventListener(\"message\", (event) => {\n  if (event.data?.type === \"start\") {\n    intervalDuration = event.data?.intervalDuration || 4000;\n    closeSocketTimeout = event.data?.closeSocketTimeout || 5000;\n    console.log(\"event=Websocket startWorker | keepalive Worker started\");\n    intervalId = setInterval(\n      (checkIfSocketClosed) => {\n        checkNetworkStatus();\n        isSocketClosed = checkIfSocketClosed;\n      },\n      intervalDuration,\n      event.data?.isSocketClosed\n    );\n\n    resetOfflineHandler();\n  }\n\n  if (event.data?.type === \"terminate\" && intervalId) {\n    console.log(\"event=Websocket terminateWorker | keepalive Worker stopped\");\n    clearInterval(intervalId);\n    intervalId = null;\n    resetOfflineHandler();\n  }\n});\n\n// Listen for online and offline events\nself.addEventListener('online', () => {\n  console.log('Network status: online');\n  checkNetworkStatus();\n});\n\nself.addEventListener('offline', () => {\n  console.log('Network status: offline');\n  checkNetworkStatus();\n});\n";