@webex/contact-center 0.0.0-next.1

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

@@ -0,0 +1,97 @@
+/**
+ * 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;
+};

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

@@ -0,0 +1,119 @@
+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.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,33 @@
+/**
+ * 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;
+}>;

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

@@ -0,0 +1,36 @@
+import * as Err from './Err';
+import { LoginOption, WebexRequestPayload } from '../../types';
+import { Failure } from './GlobalTypes';
+export declare const isValidDialNumber: (input: string) => 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;
+};
+/**
+ * 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">;

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,16 @@
+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);
+    req<TRes, TErr, TReq>(c: Conf<TRes, TErr, TReq>): Res<TRes, TReq>;
+    reqEmpty<TRes, TErr>(c: ConfEmpty<TRes, TErr>): ResEmpty<TRes>;
+    private makeAPIRequest;
+    private createPromise;
+    private bindPrint;
+    private bindCheck;
+    private readonly onMessage;
+}

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

@@ -0,0 +1,85 @@
+/**
+ * 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;
+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";

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

@@ -0,0 +1,37 @@
+import { SubscribeRequest } from '../../../types';
+import { WebSocketManager } from './WebSocketManager';
+/**
+ * Options for initializing a connection service.
+ * @typedef ConnectionServiceOptions
+ * @property {WebSocketManager} webSocketManager - The WebSocket manager instance.
+ * @property {SubscribeRequest} subscribeRequest - The subscribe request payload.
+ * @ignore
+ */
+export type ConnectionServiceOptions = {
+    webSocketManager: WebSocketManager;
+    subscribeRequest: SubscribeRequest;
+};
+/**
+ * Details about the state of a lost connection and recovery attempts.
+ * @typedef ConnectionLostDetails
+ * @property {boolean} isConnectionLost - Indicates if the connection is currently lost.
+ * @property {boolean} isRestoreFailed - Indicates if restoring the connection has failed.
+ * @property {boolean} isSocketReconnected - Indicates if the socket has been reconnected.
+ * @property {boolean} isKeepAlive - Indicates if the keep-alive mechanism is active.
+ * @ignore
+ */
+export type ConnectionLostDetails = {
+    isConnectionLost: boolean;
+    isRestoreFailed: boolean;
+    isSocketReconnected: boolean;
+    isKeepAlive: boolean;
+};
+/**
+ * Properties for connection configuration.
+ * @typedef ConnectionProp
+ * @property {number} lostConnectionRecoveryTimeout - Timeout in milliseconds for lost connection recovery.
+ * @ignore
+ */
+export type ConnectionProp = {
+    lostConnectionRecoveryTimeout: number;
+};

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

@@ -0,0 +1,52 @@
+import routingAgent from './agent';
+import routingContact from './task/contact';
+import AgentConfigService from './config';
+import { WebSocketManager } from './core/websocket/WebSocketManager';
+import { ConnectionService } from './core/websocket/connection-service';
+import { WebexSDK, SubscribeRequest } from '../types';
+import aqmDialer from './task/dialer';
+/**
+ * Services class provides centralized access to all contact center plugin services
+ * using a singleton pattern to ensure a single instance throughout the application.
+ * @private
+ * @ignore
+ * @class
+ */
+export default class Services {
+    /** Agent services for managing agent state and capabilities */
+    readonly agent: ReturnType<typeof routingAgent>;
+    /** Configuration services for agent settings */
+    readonly config: AgentConfigService;
+    /** Contact services for managing customer interactions */
+    readonly contact: ReturnType<typeof routingContact>;
+    /** Dialer services for outbound calling features */
+    readonly dialer: ReturnType<typeof aqmDialer>;
+    /** WebSocket manager for handling real-time communications */
+    readonly webSocketManager: WebSocketManager;
+    /** Connection service for managing websocket connections */
+    readonly connectionService: ConnectionService;
+    /** Singleton instance of the Services class */
+    private static instance;
+    /**
+     * Creates a new Services instance
+     * @param options - Configuration options
+     * @param options.webex - WebexSDK instance
+     * @param options.connectionConfig - Subscription configuration for websocket connection
+     */
+    constructor(options: {
+        webex: WebexSDK;
+        connectionConfig: SubscribeRequest;
+    });
+    /**
+     * Gets singleton instance of Services class
+     * Creates a new instance if one doesn't exist
+     * @param options - Configuration options
+     * @param options.webex - WebexSDK instance
+     * @param options.connectionConfig - Subscription configuration for websocket connection
+     * @returns The singleton Services instance
+     */
+    static getInstance(options: {
+        webex: WebexSDK;
+        connectionConfig: SubscribeRequest;
+    }): Services;
+}

package/dist/types/services/task/AutoWrapup.d.ts

@@ -0,0 +1,40 @@
+/**
+ * AutoWrapup class implements a timer for automatic wrap-up functionality.
+ * It handles timing the wrap-up period and executing a callback when the timer completes.
+ */
+export default class AutoWrapup {
+    private timer;
+    private startTime;
+    private readonly interval;
+    allowCancelAutoWrapup: boolean;
+    /**
+     * Creates a new AutoWrapup timer
+     * @param interval - Time in milliseconds before auto wrap-up executes
+     *  @param allowCancelAutoWrapup - Whether to allow canceling the auto wrap-up
+     */
+    constructor(interval: number, allowCancelAutoWrapup?: boolean);
+    /**
+     * Starts the auto wrap-up timer
+     * @param onComplete - Callback function to execute when timer completes
+     */
+    start(onComplete: () => void): void;
+    /**
+     * Clears the auto wrap-up timer if it's running
+     */
+    clear(): void;
+    /**
+     * Gets the remaining time in milliseconds
+     * @returns Time left in milliseconds
+     */
+    getTimeLeft(): number;
+    /**
+     * Checks if the timer is currently running
+     * @returns True if the timer is running, false otherwise
+     */
+    isRunning(): boolean;
+    /**
+     * Gets the remaining time in seconds (rounded)
+     * @returns Time left in seconds
+     */
+    getTimeLeftSeconds(): number;
+}

package/dist/types/services/task/TaskManager.d.ts

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