@webex/contact-center 3.11.0 → 3.12.0-llmrefactor.2

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 type 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,54 @@
+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;
+    /** RTD WebSocket manager for handling real-time transcription */
+    readonly rtdWebSocketManager: 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/Task.d.ts

@@ -0,0 +1,157 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { ITask, TaskData, TaskResponse, WrapupPayLoad, TaskId, TransferPayLoad, TASK_EVENTS, TaskUIControls, ConsultEndPayload, ConsultPayload, ConsultTransferPayLoad, ResumeRecordingPayload, CallId } from './types';
+import routingContact from './contact';
+import MetricsManager from '../../metrics/MetricsManager';
+import { TaskState } from './state-machine';
+import type { TaskEventPayload, TaskStateMachine, UIControlConfig, TaskActionsMap, TaskActionArgs } from './state-machine';
+import AutoWrapup from './AutoWrapup';
+import { WrapupData } from '../config/types';
+type UIControlConfigInput = Omit<UIControlConfig, 'channelType'> & {
+    channelType?: UIControlConfig['channelType'];
+};
+export default abstract class Task extends EventEmitter implements ITask {
+    protected contact: ReturnType<typeof routingContact>;
+    protected metricsManager: MetricsManager;
+    stateMachineService?: ActorRefFrom<TaskStateMachine>;
+    data: TaskData;
+    webCallMap: Record<TaskId, CallId>;
+    state?: SnapshotFrom<TaskStateMachine>;
+    private lastState?;
+    protected currentUiControls: TaskUIControls;
+    protected uiControlConfig: UIControlConfig;
+    protected wrapupData?: WrapupData;
+    autoWrapup?: AutoWrapup;
+    protected agentId?: string;
+    constructor(contact: ReturnType<typeof routingContact>, data: TaskData, uiControlConfig: UIControlConfigInput, wrapupData?: WrapupData, agentId?: string);
+    private static resolveChannelType;
+    abstract accept(): Promise<TaskResponse>;
+    decline(): Promise<TaskResponse>;
+    pauseRecording(): Promise<TaskResponse>;
+    resumeRecording(resumeRecordingPayload: ResumeRecordingPayload): Promise<TaskResponse>;
+    consult(consultPayload: ConsultPayload): Promise<TaskResponse>;
+    endConsult(consultEndPayload: ConsultEndPayload): Promise<TaskResponse>;
+    consultTransfer(consultTransferPayload?: ConsultTransferPayLoad): Promise<TaskResponse>;
+    consultConference(): Promise<TaskResponse>;
+    exitConference(): Promise<TaskResponse>;
+    transferConference(): Promise<TaskResponse>;
+    switchCall(): Promise<TaskResponse>;
+    toggleMute(): Promise<void>;
+    unregisterWebCallListeners(): void;
+    /**
+     * Cancel any in-progress auto wrap-up timer.
+     * Base implementation just clears the timer reference so subclasses inherit the behavior.
+     */
+    cancelAutoWrapupTimer(): void;
+    hold(): Promise<TaskResponse>;
+    resume(): Promise<TaskResponse>;
+    holdResume(): Promise<TaskResponse>;
+    /**
+     * Latest UI controls derived from state machine state and context.
+     */
+    get uiControls(): TaskUIControls;
+    protected updateUiControls(forceEmit?: boolean): void;
+    /**
+     * Initialize the state machine
+     */
+    private initializeStateMachine;
+    /**
+     * Send an event to the state machine
+     */
+    sendStateMachineEvent(event: TaskEventPayload): void;
+    /**
+     * Get the current state machine state
+     */
+    protected getCurrentState(): TaskState | undefined;
+    /**
+     * Compute UI controls based on current state machine state.
+     *
+     * @returns UI control states for all task actions
+     */
+    protected computeUIControls(): TaskUIControls;
+    /**
+     * Stop the state machine service
+     */
+    protected stopStateMachine(): void;
+    private static extractTaskDataFromEvent;
+    private autoAnswerIfNeeded;
+    private updateTaskFromEvent;
+    protected getStateMachineActionOverrides(): Partial<TaskActionsMap>;
+    protected getChannelSpecificActionOverrides(): Partial<TaskActionsMap>;
+    protected createEmitSelfAction(taskEvent: TASK_EVENTS, { updateTaskData }?: {
+        updateTaskData?: boolean;
+    }): ({ event }: TaskActionArgs) => void;
+    private getCommonActionOverrides;
+    /**
+     * Sets up the automatic wrap-up timer if wrap-up is required
+     */
+    protected setupAutoWrapupTimer(): void;
+    /**
+     * Cancels the automatic wrap-up timer if it's running
+     */
+    private reconcileData;
+    /**
+     *
+     * @param methodName - The name of the method that is unsupported
+     * @throws Error
+     */
+    protected unsupportedMethodError(methodName: string): void;
+    /**
+     * This method is used to update the task data.
+     * @param updatedData - TaskData
+     * @param shouldOverwrite - boolean
+     * @example
+     * ```typescript
+     * task.updateTaskData(updatedData, true);
+     * ```
+     */
+    updateTaskData(updatedData: TaskData, shouldOverwrite?: boolean): ITask;
+    /**
+     * The backend sends `interaction.media` and `interaction.participants` as complete snapshots
+     * of the current call state. `reconcileData` deep-merges and never removes keys, so entries the
+     * backend dropped (e.g. a consult leg's media and consultee participant after the consult ends)
+     * linger in `this.data`. That stale data drives incorrect UI controls (e.g. the consult button
+     * staying disabled after the consult leg is gone, until a page refresh re-hydrates cleanly).
+     * Make only these two snapshot maps authoritative to the incoming payload, leaving every other
+     * field on the generic deep-merge path (CAD and other partial updates still merge as before).
+     */
+    private pruneStaleInteractionMaps;
+    /**
+     * This is used to blind transfer or vTeam transfer the task
+     * @param transferPayload
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * const transferPayload = {
+     *  to: 'myQueueId',
+     *  destinationType: 'queue',
+     * }
+     * task.transfer(transferPayload).then(()=>{}).catch(()=>{});
+     * ```
+     */
+    transfer(transferPayload: TransferPayLoad): Promise<TaskResponse>;
+    /**
+     * This is used to end the task.
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.end().then(()=>{}).catch(()=>{})
+     *  ```
+     */
+    end(): Promise<TaskResponse>;
+    /**
+     * This is used to wrap up the task.
+     * @param wrapupPayload - WrapupPayLoad
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.wrapup(wrapupPayload).then(()=>{}).catch(()=>{})
+     * ```
+     */
+    wrapup(wrapupPayload: WrapupPayLoad): Promise<TaskResponse>;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import routingContact from './contact';
+import WebCallingService from '../WebCallingService';
+import Task from './Task';
+import { TaskData } from './types';
+import { ConfigFlags } from '../../types';
+import { WrapupData } from '../config/types';
+export default class TaskFactory {
+    /**
+     * Creates the correct Task subclass based on mediaType & loginOption
+     */
+    static createTask(contact: ReturnType<typeof routingContact>, webCallingService: WebCallingService, data: TaskData, configFlags: ConfigFlags, wrapupData?: WrapupData, agentId?: string): Task;
+}

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

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

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

@@ -0,0 +1,138 @@
+import { Interaction, ITask, TaskData } from './types';
+import { TaskContext } from './state-machine/types';
+/**
+ * Checks if the customer is still in the call (not left)
+ *
+ * @param interaction - The interaction object
+ * @param interactionId - The main interaction ID
+ * @returns true if customer is in the call
+ */
+export declare const getIsCustomerInCall: (interaction: Interaction, interactionId: string) => boolean;
+/**
+ * Gets the count of active agent participants in the conference
+ * Excludes Customer, Supervisor, and VVA participant types
+ *
+ * @param interaction - The interaction object
+ * @param interactionId - The main interaction ID
+ * @returns Number of active agent participants
+ */
+export declare const getConferenceParticipantsCount: (interaction: Interaction, interactionId: string) => number;
+/**
+ * Determines if a consult is actively in-progress for conference control gating.
+ * This is used to disable conference controls (End/Consult) only when a consult leg
+ * still exists outside the main call participants.
+ */
+export declare const getIsConsultInProgressForConferenceControls: (interaction: Interaction | undefined, mainCallId: string | undefined, selfAgentId: string | undefined) => boolean;
+export declare const getIsConsultedAgentForControls: (taskData: TaskData | null, context: TaskContext, isConsultingState: boolean) => boolean;
+export declare const getServerHoldStateForControls: (context: TaskContext, mainCallId?: string, fallbackTaskData?: TaskData | null) => boolean | undefined;
+/**
+ * Determines if the given agent is the primary agent (owner) of the task
+ * @param task - The task to check
+ * @param agentId - The agent ID to check for primary status
+ * @returns true if the agent is the primary agent, false otherwise
+ */
+export declare const isPrimary: (task: ITask, agentId: string) => boolean;
+/**
+ * Checks if the given agent is a participant in the main interaction (mainCall)
+ * @param task - The task to check
+ * @param agentId - The agent ID to check for participation
+ * @returns true if the agent is a participant in the main interaction, false otherwise
+ */
+export declare const isParticipantInMainInteraction: (task: ITask, agentId: string) => boolean;
+/**
+ * Checks if the given agent is not in the interaction or has left the interaction
+ * @param task - The task to check
+ * @param agentId - The agent ID to check
+ * @returns true if the agent is not in the interaction or has left, false otherwise
+ */
+export declare const checkParticipantNotInInteraction: (task: ITask, agentId: string) => boolean;
+/**
+ * Determines if a conference is currently in progress based on the number of active agent participants
+ * @param data - The task data to check for conference status
+ * @returns true if there are 2 or more active agent participants in the main call, false otherwise
+ *
+ * For Agent B (consulted agent), their task's interactionId may be different from the main call.
+ * We use mainInteractionId from the interaction if available, otherwise fallback to interactionId.
+ */
+export declare const getIsConferenceInProgress: (data: TaskData) => boolean;
+/** EP-DN consult merged to conference before a second agent joins the main leg (CAI-8329). */
+export declare const isEpDnConsultPendingConferenceMerge: (taskData: TaskData | undefined, selfAgentId: string | undefined) => boolean;
+/**
+ * Checks if the current agent is a secondary agent in a consultation scenario.
+ * Secondary agents are those who were consulted (not the original call owner).
+ * @param task - The task object containing interaction details
+ * @returns true if this is a secondary agent (consulted party), false otherwise
+ */
+export declare const isSecondaryAgent: (interaction: Interaction) => boolean;
+/**
+ * Checks if the current agent is a secondary EP-DN (Entry Point Dial Number) agent.
+ * This is specifically for telephony consultations to external numbers/entry points.
+ * @param interaction - The interaction object
+ * @returns true if this is a secondary EP-DN agent in telephony consultation, false otherwise
+ */
+export declare const isSecondaryEpDnAgent: (interaction: Interaction) => boolean;
+/**
+ * Checks if the task belongs to a campaign preview interaction.
+ * Campaign preview ContactEnded events are terminal cleanup events and should not trigger wrapup.
+ */
+export declare const isCampaignPreviewTask: (taskData?: TaskData | null) => boolean;
+/**
+ * Checks if auto-answer is enabled for the agent participant
+ * @param interaction - The interaction object
+ * @param agentId - Current agent ID
+ * @returns true if auto-answer is enabled, false otherwise
+ */
+export declare const isAutoAnswerEnabled: (interaction: Interaction, agentId: string) => boolean;
+/**
+ * Checks if the interaction is a WebRTC call eligible for auto-answer
+ * @param interaction - The interaction object
+ * @param loginOption - The agent's login option (BROWSER, AGENT_DN, etc.)
+ * @param webRtcEnabled - Whether WebRTC is enabled for the agent
+ * @returns true if this is a WebRTC call, false otherwise
+ */
+export declare const isWebRTCCall: (interaction: Interaction, loginOption: string, webRtcEnabled: boolean) => boolean;
+/**
+ * Checks if the interaction is a digital outbound (Email/SMS)
+ * @param interaction - The interaction object
+ * @returns true if this is a digital outbound, false otherwise
+ */
+export declare const isDigitalOutbound: (interaction: Interaction) => boolean;
+/**
+ * Checks if the outdial was initiated by the current agent
+ * @param interaction - The interaction object
+ * @param agentId - Current agent ID
+ * @returns true if agent initiated the outdial, false otherwise
+ */
+export declare const hasAgentInitiatedOutdial: (interaction: Interaction, agentId: string) => boolean;
+/**
+ * Determines if a task should be auto-answered based on interaction data
+ * Auto-answer logic handles:
+ * 1. WebRTC calls with auto-answer enabled in agent profile
+ * 2. Agent-initiated WebRTC outdial calls
+ * 3. Agent-initiated digital outbound (Email/SMS) without previous transfers
+ *
+ * @param taskData - The task data
+ * @param agentId - Current agent ID
+ * @param loginOption - Agent's login option
+ * @param webRtcEnabled - Whether WebRTC is enabled for the agent
+ * @returns true if task should be auto-answered, false otherwise
+ */
+export declare const shouldAutoAnswerTask: (taskData: TaskData, agentId: string, loginOption: string, webRtcEnabled: boolean) => boolean;
+/**
+ * Gets the consult media resource ID for switch-call operations.
+ * Searches for the consult media leg in the interaction.
+ *
+ * @param interaction - The interaction object
+ * @param consultMediaResourceId - The consult media resource ID from task data
+ * @param agentId - Current agent ID
+ * @returns The consult media resource ID or undefined
+ */
+export declare const getConsultMediaResourceId: (interaction: Interaction | undefined, consultMediaResourceId: string | undefined, agentId: string | undefined) => string | undefined;
+/**
+ * Checks if a task is a campaign preview reservation that has not yet been accepted.
+ * Campaign preview tasks should not trigger incoming call handling until the agent
+ * explicitly accepts the preview contact.
+ * @param task - The task to check
+ * @returns true if the task is a pending campaign preview reservation, false otherwise
+ */
+export declare const isCampaignPreviewReservation: (task: ITask) => boolean;

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

@@ -0,0 +1,91 @@
+/**
+ * Constants for Task Service
+ * @module @webex/contact-center/services/task/constants
+ * @ignore
+ */
+export declare const TASK_MESSAGE_TYPE = "RoutingMessage";
+export declare const TASK_API = "/v1/tasks/";
+export declare const HOLD = "/hold";
+export declare const UNHOLD = "/unhold";
+export declare const CONSULT = "/consult";
+export declare const CONSULT_ACCEPT = "/consult/accept";
+export declare const CONSULT_END = "/consult/end";
+export declare const TRANSFER = "/transfer";
+export declare const CONSULT_TRANSFER = "/consult/transfer";
+export declare const PAUSE = "/record/pause";
+export declare const RESUME = "/record/resume";
+export declare const WRAPUP = "/wrapup";
+export declare const END = "/end";
+export declare const CONSULT_CONFERENCE = "/consult/conference";
+export declare const CONFERENCE_EXIT = "/conference/exit";
+export declare const CONFERENCE_TRANSFER = "/conference/transfer";
+export declare const DIALER_API = "/v1/dialer";
+export declare const CAMPAIGN_PREVIEW_ACCEPT = "/accept";
+export declare const CAMPAIGN_PREVIEW_SKIP = "/skip";
+export declare const CAMPAIGN_PREVIEW_REMOVE = "/remove";
+/** 80-second timeout for accepting preview contact (outbound call setup takes longer than default 20s) */
+export declare const TIMEOUT_PREVIEW_ACCEPT = 80000;
+export declare const TASK_MANAGER_FILE = "taskManager";
+export declare const TASK_FILE = "task";
+/**
+ * Task data field names that should be preserved during reconciliation
+ * These fields are retained even if not present in new data during updates
+ */
+export declare const PRESERVED_TASK_DATA_FIELDS: {
+    /** Indicates if the task is in consultation state */
+    IS_CONSULTED: string;
+    /** Indicates if wrap-up is required for this task */
+    WRAP_UP_REQUIRED: string;
+    /** Indicates if a conference is currently in progress (2+ active agents) */
+    IS_CONFERENCE_IN_PROGRESS: string;
+    /** Indicates if auto-answer is in progress for this task */
+    IS_AUTO_ANSWERING: string;
+};
+/**
+ * Array of task data field names that should not be deleted during reconciliation
+ * Used by reconcileData method to preserve important task state fields
+ */
+export declare const KEYS_TO_NOT_DELETE: string[];
+/**
+ * Consultation status constants derived from state machine
+ * These values are computed and available in task.data.consultStatus
+ */
+export declare const METHODS: {
+    ACCEPT: string;
+    TOGGLE_MUTE: string;
+    DECLINE: string;
+    HOLD: string;
+    RESUME: string;
+    END: string;
+    WRAPUP: string;
+    PAUSE_RECORDING: string;
+    RESUME_RECORDING: string;
+    CONSULT: string;
+    END_CONSULT: string;
+    TRANSFER: string;
+    CONSULT_TRANSFER: string;
+    CONSULT_CONFERENCE: string;
+    EXIT_CONFERENCE: string;
+    TRANSFER_CONFERENCE: string;
+    UPDATE_TASK_DATA: string;
+    RECONCILE_DATA: string;
+    HANDLE_INCOMING_WEB_CALL: string;
+    REGISTER_TASK_LISTENERS: string;
+    HANDLE_REAL_TIME_WEBSOCKET_EVENT: string;
+    REMOVE_TASK_FROM_COLLECTION: string;
+    HANDLE_TASK_CLEANUP: string;
+    GET_TASK: string;
+    GET_ALL_TASKS: string;
+    GET_TASK_MANAGER: string;
+    SETUP_AUTO_WRAPUP_TIMER: string;
+    CANCEL_AUTO_WRAPUP_TIMER: string;
+    REQUEST_REAL_TIME_TRANSCRIPTS: string;
+};
+export declare const TRANSCRIPT_EVENT_MAP: {
+    AgentContactAssigned: string;
+    AgentConsulting: string;
+    AgentConsultConferenced: string;
+    AgentWrapup: string;
+    AgentConsultEnded: string;
+    ParticipantLeftConference: string;
+};

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

@@ -0,0 +1,69 @@
+import AqmReqs from '../core/aqm-reqs';
+import * as Contact from './types';
+export default function routingContact(aqm: AqmReqs): {
+    accept: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+    }>;
+    hold: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.HoldResumePayload;
+    }>;
+    unHold: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.HoldResumePayload;
+    }>;
+    pauseRecording: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+    }>;
+    resumeRecording: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.ResumeRecordingPayload;
+    }>;
+    consult: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.ConsultPayload;
+    }>;
+    consultEnd: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.ConsultEndPayload;
+    }>;
+    consultAccept: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+    }>;
+    blindTransfer: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.TransferPayLoad;
+    }>;
+    vteamTransfer: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.TransferPayLoad;
+    }>;
+    consultTransfer: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.ConsultTransferPayLoad;
+    }>;
+    end: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+    }>;
+    wrapup: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.WrapupPayLoad;
+    }>;
+    cancelTask: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+    }>;
+    cancelCtq: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.cancelCtq;
+    }>;
+    consultConference: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        data: Contact.ConsultConferenceData;
+    }>;
+    exitConference: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+    }>;
+    conferenceTransfer: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+    }>;
+};