@webex/contact-center 3.12.0-next.16 → 3.12.0-next.160

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

@@ -1,19 +1,36 @@
 import * as Err from './Err';
 import { LoginOption, WebexRequestPayload } from '../../types';
 import { Failure, AugmentedError } from './GlobalTypes';
-import { TaskData, ConsultTransferPayLoad, Interaction } from '../task/types';
+import { ConsultConferenceData, consultConferencePayloadData, ConsultTransferDestinationType, TaskData, Interaction } from '../task/types';
 import { DialPlan } from '../config/types';
-export declare const FALLBACK_DIAL_NUMBER_REGEX: RegExp;
+/** Returns whether a value is a non-null object with string keys. */
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Strips characters defined in the dial plan entry from the input string.
+ *
+ * @param input - The dial number to sanitize
+ * @param strippedChars - String of characters to remove from the input
+ * @returns The sanitized input with specified characters removed
+ */
+export declare const stripDialPlanChars: (input: string, strippedChars: string) => string;
 /**
  * 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.
+ * Skips validation when no dial plan entries are configured, deferring to the server.
  *
  * @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
+ * @returns true if the input matches at least one dial plan regex pattern or no entries are configured, false otherwise
  */
 export declare const isValidDialNumber: (input: string, dialPlanEntries: DialPlan['dialPlanEntity']) => boolean;
+/**
+ * Checks whether a URL's hostname is, or is a subdomain of, one of the allowed domains.
+ *
+ * @param url - The candidate URL to validate
+ * @param allowedDomains - Domains (or domain suffixes) the URL's hostname must match
+ * @returns true when the URL parses and its hostname matches an allowed domain, false otherwise
+ */
+export declare const isAllowedUrlHost: (url: string | undefined | null, allowedDomains: string[]) => boolean;
 export declare const getStationLoginErrorData: (failure: Failure, loginOption: LoginOption) => {
     message: any;
     fieldName: any;
@@ -61,14 +78,6 @@ export declare const generateTaskErrorObject: (error: any, methodName: string, m
  * @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.
@@ -98,4 +107,25 @@ export declare const calculateDestAgentId: (interaction: Interaction, agentId: s
  * @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'];
+/**
+ * Gets the destination agent ID from participants.
+ * Finds a participant who is not the current agent and is an agent type.
+ *
+ * @param participants - The participants object from interaction
+ * @param agentId - The current agent's ID
+ * @returns The destination agent ID, or undefined if none found
+ */
+export declare const buildConsultConferenceParamData: (dataPassed: consultConferencePayloadData, interactionIdPassed: string) => {
+    interactionId: string;
+    data: ConsultConferenceData;
+};
+/**
+ * Derives the consult transfer destination type based on task data.
+ * This function determines the appropriate destination type for a consult transfer
+ * by examining the destination type stored in the task data.
+ *
+ * @param taskData - The task data containing destination information
+ * @returns The derived consult transfer destination type
+ * @public
+ */
+export declare const deriveConsultTransferDestinationType: (taskData: TaskData) => ConsultTransferDestinationType;

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

@@ -11,6 +11,7 @@ declare class WebexRequest {
         resource: string;
         method: HTTP_METHODS;
         body?: RequestBody;
+        headers?: Record<string, string | null>;
     }): Promise<IHttpResponse>;
     /**
      * This is used for uploading the logs to backend/mats.

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

@@ -67,6 +67,13 @@ export declare const PARTICIPANT_TYPES: {
 };
 /** Interaction state for consultation */
 export declare const STATE_CONSULT = "consult";
+/**
+ * Trusted domains for the RoutingNotifs WebSocket connection. A `webSocketUrl` returned by the
+ * subscribe/register API is only opened when its hostname matches one of these domains exactly
+ * or is a subdomain of one of them.
+ * @ignore
+ */
+export declare const ALLOWED_ROUTING_NOTIFS_DOMAINS: string[];
 export declare const METHODS: {
     REQUEST: string;
     UPLOAD_LOGS: string;

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

@@ -18,6 +18,8 @@ export type Req<TRes, TErr> = {
     url: string;
     host?: string;
     method?: HTTP_METHODS;
+    /** Suppress request URLs and routing payloads from AQM logs for sensitive operations. */
+    redactSensitiveLogs?: boolean;
     err?: ((errObj: WebexRequestPayload) => Err.Details<'Service.reqs.generic.failure'>) | Err.IdsMessage | ((e: WebexRequestPayload) => Err.Message | Err.Details<Err.IdsDetails>);
     notifSuccess: {
         bind: Bind;

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

@@ -33,3 +33,4 @@ export declare class WebSocketManager extends EventEmitter {
     private connect;
     private webSocketOnCloseHandler;
 }
+export default WebSocketManager;

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

@@ -1,5 +1,5 @@
 import { SubscribeRequest } from '../../../types';
-import { WebSocketManager } from './WebSocketManager';
+import type WebSocketManager from './WebSocketManager';
 /**
  * Options for initializing a connection service.
  * @typedef ConnectionServiceOptions

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

@@ -23,7 +23,7 @@ export default class Services {
     readonly dialer: ReturnType<typeof aqmDialer>;
     /** WebSocket manager for handling real-time communications */
     readonly webSocketManager: WebSocketManager;
-    /** RTD WebSocket manager for handling realtime transcription */
+    /** RTD WebSocket manager for handling real-time transcription */
     readonly rtdWebSocketManager: WebSocketManager;
     /** Connection service for managing websocket connections */
     readonly connectionService: ConnectionService;

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

@@ -0,0 +1,186 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { ITask, TaskData, TaskResponse, WrapupPayLoad, TaskId, TransferPayLoad, TASK_EVENTS, TaskUIControls, DropConferenceParticipantPayload, ConsultEndPayload, ConsultPayload, ConsultTransferPayLoad, ResumeRecordingPayload, CallId, AISummaryAction, AISummary, AISummaryResponse, AISummaryFeatureEnablement, AISummaryCapabilities, TaskToggleMuteOptions, TaskTransmitDtmfOptions } 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 type { WrapupData } from '../config/types';
+import type ApiAIAssistant from '../ApiAiAssistant';
+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;
+    protected agentName?: string;
+    private apiAIAssistant?;
+    aiSummaryCapabilities: Readonly<AISummaryCapabilities>;
+    constructor(contact: ReturnType<typeof routingContact>, data: TaskData, uiControlConfig: UIControlConfigInput, wrapupData?: WrapupData, agentId?: string, agentName?: string, apiAIAssistant?: ApiAIAssistant);
+    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>;
+    dropConferenceParticipant(payload: DropConferenceParticipantPayload): Promise<TaskResponse>;
+    exitConference(): Promise<TaskResponse>;
+    transferConference(): Promise<TaskResponse>;
+    switchCall(): Promise<TaskResponse>;
+    toggleMute(options?: TaskToggleMuteOptions): Promise<void>;
+    transmitDtmf(options: TaskTransmitDtmfOptions): 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>;
+    setFeatureEnablement(enablement: AISummaryFeatureEnablement): void;
+    clearFeatureEnablement(): void;
+    requestPostCallSummary(): Promise<AISummary>;
+    sendPostCallSummaryResponse(response: AISummaryResponse): Promise<void>;
+    requestMidCallSummary(action: AISummaryAction): Promise<AISummary>;
+    sendMidCallSummaryResponse(response: AISummaryResponse, action: AISummaryAction): Promise<void>;
+    private static getAISummaryFailureCode;
+    /**
+     * 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
+     */
+    /**
+     * Update wxApp thick-client answer flag at runtime (Voice overrides).
+     */
+    setEnableWxBetterTogether(_enabled: boolean): void;
+    /**
+     * Apply wxApp mute state from external sync (Voice overrides).
+     */
+    applyWxAppMuteStateFromSync(_incomingCallId: string, _muted: boolean): void;
+    /**
+     * Hook for post-assign wxApp sync (Voice overrides).
+     */
+    protected onTaskAssigned(): void;
+    /**
+     * Hook for post-hydrate wxApp sync (Voice overrides).
+     */
+    protected onTaskHydrated(): void;
+    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): never;
+    /**
+     * 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,14 @@
+import routingContact from './contact';
+import WebCallingService from '../WebCallingService';
+import AnswerCallOnWebexService from '../AnswerCallOnWebexService';
+import Task from './Task';
+import { TaskData } from './types';
+import { ConfigFlags } from '../../types';
+import type { WrapupData } from '../config/types';
+import type ApiAIAssistant from '../ApiAiAssistant';
+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, agentName?: string, answerCallOnWebexService?: AnswerCallOnWebexService, apiAIAssistant?: ApiAIAssistant): Task;
+}

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

@@ -1,4 +1,35 @@
 import { Interaction, ITask, TaskData } from './types';
+import { TaskContext } from './state-machine/types';
+type AISummaryError = Error & {
+    data?: Record<string, unknown>;
+};
+export declare const isNonEmptyString: (value: unknown) => value is string;
+export declare const createSummaryError: (errorCode: string) => AISummaryError;
+/**
+ * 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
@@ -22,10 +53,15 @@ export declare const isParticipantInMainInteraction: (task: ITask, agentId: stri
 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 TaskData - The payLoad data to check for conference status
+ * @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).
@@ -36,10 +72,15 @@ 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 task - The task object containing interaction details
+ * @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
@@ -82,6 +123,16 @@ export declare const hasAgentInitiatedOutdial: (interaction: Interaction, agentI
  * @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
@@ -90,3 +141,4 @@ export declare const shouldAutoAnswerTask: (taskData: TaskData, agentId: string,
  * @returns true if the task is a pending campaign preview reservation, false otherwise
  */
 export declare const isCampaignPreviewReservation: (task: ITask) => boolean;
+export {};

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

@@ -0,0 +1,11 @@
+import { TaskState } from './state-machine/constants';
+export type WebexCallingDeviceDetails = {
+    deviceType: string;
+    deviceId: string;
+    deviceCallId: string;
+};
+export declare function getWebexCallingDeviceDetailsForAgent(agentId: string | undefined, participants: unknown): WebexCallingDeviceDetails | undefined;
+export declare function isWebexCallingCallForAgent(agentId: string | undefined, participants: unknown): boolean;
+/** Matches wxAppVoiceMethods.getWebexCallingCallId engaged semantics for uiControls. */
+export declare function isWxAppEngagedForControls(enableWxBetterTogether: boolean, agentId: string | undefined, participants: unknown, state: TaskState): boolean;
+export declare function decodedLineOwnerId(lineOwnerId?: string): string | undefined;

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

@@ -11,6 +11,8 @@ export declare const CONSULT = "/consult";
 export declare const CONSULT_ACCEPT = "/consult/accept";
 export declare const CONSULT_END = "/consult/end";
 export declare const TRANSFER = "/transfer";
+/** Backend destination value for direct entry-point transfers through the vteam endpoint. */
+export declare const ENTRY_POINT_TRANSFER_DESTINATION_TYPE = "entrypointDialNumber";
 export declare const CONSULT_TRANSFER = "/consult/transfer";
 export declare const PAUSE = "/record/pause";
 export declare const RESUME = "/record/resume";
@@ -25,6 +27,9 @@ 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;
+/** RTD result deadline; the initiating HTTP acknowledgement uses the 20-second service timeout. */
+export declare const AI_SUMMARY_DURATION_MS = 15000;
+export declare const AI_SUMMARY_REQUEST_CANCELLED: "AI_SUMMARY_REQUEST_CANCELLED";
 export declare const TASK_MANAGER_FILE = "taskManager";
 export declare const TASK_FILE = "task";
 /**
@@ -46,6 +51,10 @@ export declare const PRESERVED_TASK_DATA_FIELDS: {
  * 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;
@@ -61,6 +70,7 @@ export declare const METHODS: {
     TRANSFER: string;
     CONSULT_TRANSFER: string;
     CONSULT_CONFERENCE: string;
+    DROP_CONFERENCE_PARTICIPANT: string;
     EXIT_CONFERENCE: string;
     TRANSFER_CONFERENCE: string;
     UPDATE_TASK_DATA: string;
@@ -75,6 +85,13 @@ export declare const METHODS: {
     GET_TASK_MANAGER: string;
     SETUP_AUTO_WRAPUP_TIMER: string;
     CANCEL_AUTO_WRAPUP_TIMER: string;
+    REQUEST_REAL_TIME_TRANSCRIPTS: string;
+    REQUEST_POST_CALL_SUMMARY: string;
+    SEND_POST_CALL_SUMMARY_RESPONSE: string;
+    REQUEST_MID_CALL_SUMMARY: string;
+    SEND_MID_CALL_SUMMARY_RESPONSE: string;
+    HANDLE_AI_SUMMARY_EVENT: string;
+    CLEAR_AI_SUMMARY_STATE: string;
 };
 export declare const TRANSCRIPT_EVENT_MAP: {
     AgentContactAssigned: string;

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

@@ -60,6 +60,10 @@ export default function routingContact(aqm: AqmReqs): {
         interactionId: string;
         data: Contact.ConsultConferenceData;
     }>;
+    dropConferenceParticipant: import("../core/types").Res<Contact.AgentContact, {
+        interactionId: string;
+        participantId: string;
+    }>;
     exitConference: import("../core/types").Res<Contact.AgentContact, {
         interactionId: string;
     }>;

package/dist/types/services/task/digital/Digital.d.ts

@@ -0,0 +1,23 @@
+import { ConsultTransferDestinationConfig, IDigital, TaskResponse, TaskData } from '../types';
+import type { WrapupData } from '../../config/types';
+import type ApiAIAssistant from '../../ApiAiAssistant';
+import Task from '../Task';
+import routingContact from '../contact';
+export default class Digital extends Task implements IDigital {
+    constructor(contact: ReturnType<typeof routingContact>, data: TaskData, wrapupData?: WrapupData, agentId?: string, consultTransferConfig?: ConsultTransferDestinationConfig, agentName?: string, apiAIAssistant?: ApiAIAssistant);
+    /**
+     * Refresh the digital task with the latest backend payload and recompute UI controls.
+     */
+    updateTaskData(newData: TaskData, shouldOverwrite?: boolean): IDigital;
+    /**
+     * This is used for incoming digital task accept by agent.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.accept().then(()=>{}).catch(()=>{})
+     * ```
+     */
+    accept(): Promise<TaskResponse>;
+}