@webex/contact-center 3.8.1 → 3.9.0-multi-llms.2

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

@@ -0,0 +1,76 @@
+import { WebexSDK } from '../types';
+import type { ContactServiceQueuesResponse, ContactServiceQueueSearchParams } from '../types';
+/**
+ * Queue API class for managing Webex Contact Center contact service queues.
+ * Provides functionality to fetch contact service queues using the queue API.
+ *
+ * @class Queue
+ * @public
+ * @example
+ * ```typescript
+ * import Webex from 'webex';
+ *
+ * const webex = new Webex({ credentials: 'YOUR_ACCESS_TOKEN' });
+ * const cc = webex.cc;
+ *
+ * // Register and login first
+ * await cc.register();
+ * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+ *
+ * // Get Queue API instance from ContactCenter
+ * const queueAPI = cc.queue;
+ *
+ * // Get all queues
+ * const queues = await queueAPI.getQueues();
+ *
+ * // Get queues with pagination
+ * const queues = await queueAPI.getQueues({
+ *   page: 0,
+ *   pageSize: 50
+ * });
+ *
+ * // Search for specific queues
+ * const searchResults = await queueAPI.getQueues({
+ *   search: 'support',
+ *   filter: 'name=="Support Queue"'
+ * });
+ * ```
+ */
+export declare class Queue {
+    private webexRequest;
+    private webex;
+    private metricsManager;
+    private pageCache;
+    /**
+     * Creates an instance of Queue
+     * @param {WebexSDK} webex - The Webex SDK instance
+     * @public
+     */
+    constructor(webex: WebexSDK);
+    /**
+     * Fetches contact service queues for the organization
+     * @param {ContactServiceQueueSearchParams} [params] - Search and pagination parameters
+     * @returns {Promise<ContactServiceQueuesResponse>} Promise resolving to contact service queues
+     * @throws {Error} If the API call fails
+     * @public
+     * @example
+     * ```typescript
+     * // Get all queues with default pagination
+     * const response = await queueAPI.getQueues();
+     *
+     * // Get queues with specific pagination
+     * const response = await queueAPI.getQueues({
+     *   page: 0,
+     *   pageSize: 25
+     * });
+     *
+     * // Search for queues
+     * const response = await queueAPI.getQueues({
+     *   search: 'support',
+     *   filter: 'queueType=="INBOUND"'
+     * });
+     * ```
+     */
+    getQueues(params?: ContactServiceQueueSearchParams): Promise<ContactServiceQueuesResponse>;
+}
+export default Queue;

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

@@ -51,7 +51,6 @@ export declare const METHODS: {
     GET_TENANT_DATA: string;
     GET_URL_MAPPING: string;
     GET_DIAL_PLAN_DATA: string;
-    GET_QUEUES: string;
     PARSE_AGENT_CONFIGS: string;
     GET_URL_MAPPING_UTIL: string;
     GET_MSFT_CONFIG: string;
@@ -200,4 +199,39 @@ export declare const endPointMap: {
      * @ignore
      */
     queueList: (orgId: string, queryParams: string) => string;
+    /**
+     * Gets the endpoint for entry points list with custom query parameters.
+     * @param orgId - Organization ID.
+     * @param queryParams - Query parameters string.
+     * @returns The endpoint URL string.
+     * @public
+     * @example
+     * const url = endPointMap.entryPointList('org123', 'page=0&pageSize=10');
+     * @ignore
+     */
+    entryPointList: (orgId: string, queryParams: string) => string;
+    /**
+     * Gets the endpoint for address book entries with custom query parameters.
+     * @param orgId - Organization ID.
+     * @param addressBookId - Address book ID.
+     * @param queryParams - Query parameters string.
+     * @returns The endpoint URL string.
+     * @public
+     * @example
+     * const url = endPointMap.addressBookEntries('org123', 'book456', 'page=0&pageSize=10');
+     * @ignore
+     */
+    addressBookEntries: (orgId: string, addressBookId: string, queryParams: string) => string;
+    /**
+     * Gets the endpoint for outdial ANI entries with custom query parameters.
+     * @param orgId - Organization ID.
+     * @param outdialANI - Outdial ANI ID.
+     * @param queryParams - Query parameters string.
+     * @returns The endpoint URL string.
+     * @public
+     * @example
+     * const url = endPointMap.outdialAniEntries('org123', 'ani456', 'page=0&pageSize=10');
+     * @ignore
+     */
+    outdialAniEntries: (orgId: string, outdialANI: string, queryParams: string) => string;
 };

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

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module AgentConfigService
  */
-import { DesktopProfileResponse, ListAuxCodesResponse, AgentResponse, OrgInfo, OrgSettings, TenantData, URLMapping, TeamList, DialPlanEntity, Profile, ListTeamsResponse, AuxCode, MultimediaProfileResponse, SiteInfo, ContactServiceQueue } from './types';
+import { DesktopProfileResponse, ListAuxCodesResponse, AgentResponse, TenantData, OrgInfo, OrgSettings, URLMapping, TeamList, DialPlanEntity, Profile, ListTeamsResponse, AuxCode, MultimediaProfileResponse, SiteInfo, OutdialAniEntriesResponse, OutdialAniParams } from './types';
 /**
  * The AgentConfigService class provides methods to fetch agent configuration data.
  * @private
@@ -156,16 +156,13 @@ export default class AgentConfigService {
      */
     getDialPlanData(orgId: string): Promise<DialPlanEntity[]>;
     /**
-     * Fetches the list of queues for the given orgId.
+     * Fetches outdial ANI (Automatic Number Identification) entries for the given orgId and outdial ANI ID.
      * @ignore
-     * @param {string} orgId - organization ID for which the queues are to be fetched.
-     * @param {number} page - the page number to fetch.
-     * @param {number} pageSize - the number of queues to fetch per page.
-     * @param {string} search - optional search string
-     * @param {string} filter - optional filter string
-     * @returns Promise<ContactServiceQueue[]> - A promise that resolves to the list of contact service queues.
+     * @param {string} orgId - organization ID for which the outdial ANI entries are to be fetched.
+     * @param {OutdialAniParams} params - parameters object containing outdialANI and optional pagination/filtering options
+     * @returns {Promise<OutdialAniEntriesResponse>} - A promise that resolves to the outdial ANI entries response.
      * @throws {Error} - Throws an error if the API call fails or if the response status is not 200.
      * @private
      */
-    getQueues(orgId: string, page: number, pageSize: number, search?: string, filter?: string): Promise<ContactServiceQueue[]>;
+    getOutdialAniEntries(orgId: string, params: OutdialAniParams): Promise<OutdialAniEntriesResponse>;
 }

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

@@ -38,6 +38,28 @@ export declare const CC_TASK_EVENTS: {
     readonly AGENT_CONSULT_END_FAILED: "AgentConsultEndFailed";
     /** Event emitted when consultation conference ends */
     readonly AGENT_CONSULT_CONFERENCE_ENDED: "AgentConsultConferenceEnded";
+    /** Event emitted when consultation conference is in progress */
+    readonly AGENT_CONSULT_CONFERENCING: "AgentConsultConferencing";
+    /** Event emitted when consultation conference starts */
+    readonly AGENT_CONSULT_CONFERENCED: "AgentConsultConferenced";
+    /** Event emitted when consultation conference fails */
+    readonly AGENT_CONSULT_CONFERENCE_FAILED: "AgentConsultConferenceFailed";
+    /** Event emitted when participant joins conference */
+    readonly PARTICIPANT_JOINED_CONFERENCE: "ParticipantJoinedConference";
+    /** Event emitted when participant leaves conference */
+    readonly PARTICIPANT_LEFT_CONFERENCE: "ParticipantLeftConference";
+    /** Event emitted when participant leaving conference fails */
+    readonly PARTICIPANT_LEFT_CONFERENCE_FAILED: "ParticipantLeftConferenceFailed";
+    /** Event emitted when consultation conference end fails */
+    readonly AGENT_CONSULT_CONFERENCE_END_FAILED: "AgentConsultConferenceEndFailed";
+    /** Event emitted when conference is successfully transferred */
+    readonly AGENT_CONFERENCE_TRANSFERRED: "AgentConferenceTransferred";
+    /** Event emitted when conference transfer fails */
+    readonly AGENT_CONFERENCE_TRANSFER_FAILED: "AgentConferenceTransferFailed";
+    /** Event emitted when consulted participant is moving/being transferred */
+    readonly CONSULTED_PARTICIPANT_MOVING: "ConsultedParticipantMoving";
+    /** Event emitted for post-call activity by participant */
+    readonly PARTICIPANT_POST_CALL_ACTIVITY: "ParticipantPostCallActivity";
     /** Event emitted when contact is blind transferred */
     readonly AGENT_BLIND_TRANSFERRED: "AgentBlindTransferred";
     /** Event emitted when blind transfer fails */
@@ -165,6 +187,28 @@ export declare const CC_EVENTS: {
     readonly AGENT_CONSULT_END_FAILED: "AgentConsultEndFailed";
     /** Event emitted when consultation conference ends */
     readonly AGENT_CONSULT_CONFERENCE_ENDED: "AgentConsultConferenceEnded";
+    /** Event emitted when consultation conference is in progress */
+    readonly AGENT_CONSULT_CONFERENCING: "AgentConsultConferencing";
+    /** Event emitted when consultation conference starts */
+    readonly AGENT_CONSULT_CONFERENCED: "AgentConsultConferenced";
+    /** Event emitted when consultation conference fails */
+    readonly AGENT_CONSULT_CONFERENCE_FAILED: "AgentConsultConferenceFailed";
+    /** Event emitted when participant joins conference */
+    readonly PARTICIPANT_JOINED_CONFERENCE: "ParticipantJoinedConference";
+    /** Event emitted when participant leaves conference */
+    readonly PARTICIPANT_LEFT_CONFERENCE: "ParticipantLeftConference";
+    /** Event emitted when participant leaving conference fails */
+    readonly PARTICIPANT_LEFT_CONFERENCE_FAILED: "ParticipantLeftConferenceFailed";
+    /** Event emitted when consultation conference end fails */
+    readonly AGENT_CONSULT_CONFERENCE_END_FAILED: "AgentConsultConferenceEndFailed";
+    /** Event emitted when conference is successfully transferred */
+    readonly AGENT_CONFERENCE_TRANSFERRED: "AgentConferenceTransferred";
+    /** Event emitted when conference transfer fails */
+    readonly AGENT_CONFERENCE_TRANSFER_FAILED: "AgentConferenceTransferFailed";
+    /** Event emitted when consulted participant is moving/being transferred */
+    readonly CONSULTED_PARTICIPANT_MOVING: "ConsultedParticipantMoving";
+    /** Event emitted for post-call activity by participant */
+    readonly PARTICIPANT_POST_CALL_ACTIVITY: "ParticipantPostCallActivity";
     /** Event emitted when contact is blind transferred */
     readonly AGENT_BLIND_TRANSFERRED: "AgentBlindTransferred";
     /** Event emitted when blind transfer fails */
@@ -1048,66 +1092,43 @@ export type CallDistributionGroup = {
     duration: number;
 };
 /**
- * Comprehensive configuration for a contact service queue
+ * Represents a single outdial ANI (Automatic Number Identification) entry
  * @public
  */
-export type ContactServiceQueue = {
-    /** Unique identifier for the queue */
+export type OutdialAniEntry = {
+    /** Unique identifier for the ANI entry */
     id: string;
-    /** Queue name */
+    /** Display name for the ANI entry */
     name: string;
-    /** Queue description */
-    description: string;
-    /** Type of queue */
-    queueType: string;
-    /** Whether to check agent availability before routing */
-    checkAgentAvailability: boolean;
-    /** Type of channel this queue handles */
-    channelType: string;
-    /** Service level threshold in seconds */
-    serviceLevelThreshold: number;
-    /** Maximum number of active contacts allowed */
-    maxActiveContacts: number;
-    /** Maximum time contacts can wait in queue (seconds) */
-    maxTimeInQueue: number;
-    /** Default music on hold media file ID */
-    defaultMusicInQueueMediaFileId: string;
-    /** Queue timezone */
-    timezone: string;
-    /** Whether queue is active */
-    active: boolean;
-    /** Whether outbound campaign routing is enabled */
-    outdialCampaignEnabled: boolean;
-    /** Whether monitoring is permitted */
-    monitoringPermitted: boolean;
-    /** Whether parking is permitted */
-    parkingPermitted: boolean;
-    /** Whether recording is permitted */
-    recordingPermitted: boolean;
-    /** Whether recording all calls is permitted */
-    recordingAllCallsPermitted: boolean;
-    /** Whether pausing recordings is permitted */
-    pauseRecordingPermitted: boolean;
-    /** Maximum recording pause duration in seconds */
-    recordingPauseDuration: number;
-    /** Control flow script URL */
-    controlFlowScriptUrl: string;
-    /** IVR requeue URL */
-    ivrRequeueUrl: string;
-    /** Type of routing strategy */
-    routingType: string;
-    /** Queue-specific routing type */
-    queueRoutingType: string;
-    /** Queue skill requirements for routing */
-    queueSkillRequirements: object[];
-    /** Associated agents */
-    agents: object[];
-    /** Call distribution group configurations */
-    callDistributionGroups: CallDistributionGroup[];
-    /** Associated resource links */
-    links: Array<string>;
-    /** Timestamp when queue was created */
-    createdTime: string;
-    /** Timestamp when queue was last updated */
-    lastUpdatedTime: string;
+    /** Phone number associated with this ANI entry */
+    number: string;
+    /** Related links for this ANI entry */
+    links: string[];
+    /** Timestamp when this entry was created (Unix timestamp in milliseconds) */
+    createdTime: number;
+    /** Timestamp when this entry was last updated (Unix timestamp in milliseconds) */
+    lastUpdatedTime: number;
+};
+/**
+ * Response structure for outdial ANI entries API call
+ * @public
+ */
+export type OutdialAniEntriesResponse = OutdialAniEntry[];
+/**
+ * Parameters for fetching outdial ANI entries
+ * @public
+ */
+export type OutdialAniParams = {
+    /** Outdial ANI ID from agent profile */
+    outdialANI: string;
+    /** Page number for pagination (optional) */
+    page?: number;
+    /** Number of entries per page (optional) */
+    pageSize?: number;
+    /** Search string to filter entries (optional) */
+    search?: string;
+    /** Filter expression for advanced filtering (optional) */
+    filter?: string;
+    /** Comma-separated list of attributes to include in response (optional) */
+    attributes?: string;
 };

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

@@ -31,3 +31,28 @@ export type Failure = Msg<{
     /** 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

@@ -1,6 +1,7 @@
 import * as Err from './Err';
 import { LoginOption, WebexRequestPayload } from '../../types';
-import { Failure } from './GlobalTypes';
+import { Failure, AugmentedError } from './GlobalTypes';
+import { TaskData, ConsultTransferPayLoad, ConsultConferenceData, consultConferencePayloadData, Interaction } from '../task/types';
 export declare const isValidDialNumber: (input: string) => boolean;
 export declare const getStationLoginErrorData: (failure: Failure, loginOption: LoginOption) => {
     message: any;
@@ -23,6 +24,21 @@ export declare const getErrorDetails: (error: any, methodName: string, moduleNam
     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.
  *
@@ -34,3 +50,26 @@ export declare const getErrorDetails: (error: any, methodName: string, moduleNam
  * @ignore
  */
 export declare const createErrDetailsObject: (errObj: WebexRequestPayload) => Err.Details<"Service.reqs.generic.failure">;
+/**
+ * Gets the destination agent ID from participants data by finding the first
+ * non-customer participant that is not the current agent and is not in wrap-up state.
+ *
+ * @param participants - The participants data from the interaction
+ * @param agentId - The current agent's ID to exclude from the search
+ * @returns The destination agent ID, or empty string if none found
+ */
+export declare const getDestinationAgentId: (participants: Interaction['participants'], agentId: string) => string;
+export declare const deriveConsultTransferDestinationType: (taskData?: TaskData) => ConsultTransferPayLoad['destinationType'];
+/**
+ * Builds consult conference parameter data using EXACT Agent Desktop logic.
+ * This matches the Agent Desktop's consultConference implementation exactly.
+ *
+ * @param dataPassed - Original consultation data from Agent Desktop format
+ * @param interactionIdPassed - The interaction ID for the task
+ * @returns Object with interactionId and ConsultConferenceData matching Agent Desktop format
+ * @public
+ */
+export declare const buildConsultConferenceParamData: (dataPassed: consultConferencePayloadData, interactionIdPassed: string) => {
+    interactionId: string;
+    data: ConsultConferenceData;
+};

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

@@ -16,6 +16,9 @@ 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 TASK_MANAGER_FILE = "taskManager";
 export declare const TASK_FILE = "task";
 export declare const METHODS: {
@@ -32,6 +35,9 @@ export declare const METHODS: {
     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;

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

@@ -56,4 +56,14 @@ export default function routingContact(aqm: AqmReqs): {
         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;
+    }>;
 };

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

@@ -110,6 +110,7 @@ export default class Task extends EventEmitter implements ITask {
     webCallMap: Record<TaskId, CallId>;
     private wrapupData;
     autoWrapup?: AutoWrapup;
+    private agentId;
     /**
      * Creates a new Task instance which provides the following features:
      * @param contact - The routing contact service instance
@@ -117,7 +118,7 @@ export default class Task extends EventEmitter implements ITask {
      * @param data - Initial task data
      * @param wrapupData - Wrap-up configuration data
      */
-    constructor(contact: ReturnType<typeof routingContact>, webCallingService: WebCallingService, data: TaskData, wrapupData: WrapupData);
+    constructor(contact: ReturnType<typeof routingContact>, webCallingService: WebCallingService, data: TaskData, wrapupData: WrapupData, agentId: string);
     /**
      * Sets up the automatic wrap-up timer if wrap-up is required
      * @private
@@ -565,5 +566,46 @@ export default class Task extends EventEmitter implements ITask {
      *   .catch(error => console.error('Failed to complete queue consultation transfer:', error));
      * ```
      */
-    consultTransfer(consultTransferPayload: ConsultTransferPayLoad): Promise<TaskResponse>;
+    consultTransfer(consultTransferPayload?: ConsultTransferPayLoad): Promise<TaskResponse>;
+    /**
+     * Starts a consultation conference by merging the consultation call with the main call
+     *
+     * Creates a three-way conference between the agent, customer, and consulted party
+     * Extracts required consultation data from the current task data
+     * On success, emits a `task:conferenceStarted` event
+     *
+     * @returns Promise<TaskResponse> - Response from the consultation conference API
+     * @throws Error if the operation fails or if consultation data is invalid
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await task.consultConference();
+     *   console.log('Conference started successfully');
+     * } catch (error) {
+     *   console.error('Failed to start conference:', error);
+     * }
+     * ```
+     */
+    consultConference(): Promise<TaskResponse>;
+    /**
+     * Exits the current conference by removing the agent from the conference call
+     *
+     * Exits the agent from the conference, leaving the customer and consulted party connected
+     * On success, emits a `task:conferenceEnded` event
+     *
+     * @returns Promise<TaskResponse> - Response from the conference exit API
+     * @throws Error if the operation fails or if no active conference exists
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await task.exitConference();
+     *   console.log('Successfully exited conference');
+     * } catch (error) {
+     *   console.error('Failed to exit conference:', error);
+     * }
+     * ```
+     */
+    exitConference(): Promise<TaskResponse>;
 }

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

@@ -334,7 +334,117 @@ export declare enum TASK_EVENTS {
      * });
      * ```
      */
-    TASK_OFFER_CONTACT = "task:offerContact"
+    TASK_OFFER_CONTACT = "task:offerContact",
+    /**
+     * Triggered when a conference is being established
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_CONFERENCE_ESTABLISHING, (task: ITask) => {
+     *   console.log('Conference establishing:', task.data.interactionId);
+     *   // Handle conference setup in progress
+     * });
+     * ```
+     */
+    TASK_CONFERENCE_ESTABLISHING = "task:conferenceEstablishing",
+    /**
+     * Triggered when a conference is started successfully
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_CONFERENCE_STARTED, (task: ITask) => {
+     *   console.log('Conference started:', task.data.interactionId);
+     *   // Handle conference start
+     * });
+     * ```
+     */
+    TASK_CONFERENCE_STARTED = "task:conferenceStarted",
+    /**
+     * Triggered when a conference fails to start
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_CONFERENCE_FAILED, (task: ITask) => {
+     *   console.log('Conference failed:', task.data.interactionId);
+     *   // Handle conference failure
+     * });
+     * ```
+     */
+    TASK_CONFERENCE_FAILED = "task:conferenceFailed",
+    /**
+     * Triggered when a conference is ended successfully
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_CONFERENCE_ENDED, (task: ITask) => {
+     *   console.log('Conference ended:', task.data.interactionId);
+     *   // Handle conference end
+     * });
+     * ```
+     */
+    TASK_CONFERENCE_ENDED = "task:conferenceEnded",
+    /**
+     * Triggered when a participant joins the conference
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_PARTICIPANT_JOINED, (task: ITask) => {
+     *   console.log('Participant joined conference:', task.data.interactionId);
+     *   // Handle participant joining
+     * });
+     * ```
+     */
+    TASK_PARTICIPANT_JOINED = "task:participantJoined",
+    /**
+     * Triggered when a participant leaves the conference
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_PARTICIPANT_LEFT, (task: ITask) => {
+     *   console.log('Participant left conference:', task.data.interactionId);
+     *   // Handle participant leaving
+     * });
+     * ```
+     */
+    TASK_PARTICIPANT_LEFT = "task:participantLeft",
+    /**
+     * Triggered when conference transfer is successful
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_CONFERENCE_TRANSFERRED, (task: ITask) => {
+     *   console.log('Conference transferred:', task.data.interactionId);
+     *   // Handle successful conference transfer
+     * });
+     * ```
+     */
+    TASK_CONFERENCE_TRANSFERRED = "task:conferenceTransferred",
+    /**
+     * Triggered when conference transfer fails
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, (task: ITask) => {
+     *   console.log('Conference transfer failed:', task.data.interactionId);
+     *   // Handle failed conference transfer
+     * });
+     * ```
+     */
+    TASK_CONFERENCE_TRANSFER_FAILED = "task:conferenceTransferFailed",
+    /**
+     * Triggered when ending a conference fails
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_CONFERENCE_END_FAILED, (task: ITask) => {
+     *   console.log('Conference end failed:', task.data.interactionId);
+     *   // Handle failed conference end
+     * });
+     * ```
+     */
+    TASK_CONFERENCE_END_FAILED = "task:conferenceEndFailed",
+    /**
+     * Triggered when participant exit from conference fails
+     * @example
+     * ```typescript
+     * task.on(TASK_EVENTS.TASK_PARTICIPANT_LEFT_FAILED, (task: ITask) => {
+     *   console.log('Participant failed to leave conference:', task.data.interactionId);
+     *   // Handle failed participant exit
+     * });
+     * ```
+     */
+    TASK_PARTICIPANT_LEFT_FAILED = "task:participantLeftFailed"
 }
 /**
  * Represents a customer interaction within the contact center system
@@ -828,6 +938,18 @@ export type ConsultConferenceData = {
     /** Type of destination (e.g., 'agent', 'queue') */
     destinationType: string;
 };
+/**
+ * Legacy consultation conference data type matching Agent Desktop
+ * @public
+ */
+export type consultConferencePayloadData = {
+    /** Identifier of the agent initiating consult/conference */
+    agentId: string;
+    /** Type of destination (e.g., 'agent', 'queue') */
+    destinationType: string;
+    /** Identifier of the destination agent */
+    destAgentId: string;
+};
 /**
  * Parameters required for cancelling a consult to queue operation
  * @public
@@ -875,6 +997,8 @@ export type DialerPayload = {
     mediaType: 'telephony' | 'chat' | 'social' | 'email';
     /** The outbound type for the task */
     outboundType: 'OUTDIAL' | 'CALLBACK' | 'EXECUTE_FLOW';
+    /** The Outdial ANI number that will be used while making a call to the customer.  */
+    origin: string;
 };
 /**
  * Data structure for cleaning up contact resources