@webex/contact-center 3.11.0 → 3.12.0-mobius-socket.1

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

@@ -0,0 +1,650 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { CallId } from '@webex/calling/dist/types/common/types';
+import routingContact from './contact';
+import { ITask, TaskResponse, TaskData, TaskId, WrapupPayLoad, ResumeRecordingPayload, ConsultPayload, ConsultEndPayload, TransferPayLoad, ConsultTransferPayLoad } from './types';
+import WebCallingService from '../WebCallingService';
+import AutoWrapup from './AutoWrapup';
+import { WrapupData } from '../config/types';
+/**
+ * Task class represents a contact center task/interaction that can be managed by an agent.
+ * This class provides all the necessary methods to manage tasks in a contact center environment,
+ * handling various call control operations and task lifecycle management.
+ *
+ * - Task Lifecycle Management:
+ *   - {@link accept} - Accept incoming task
+ *   - {@link decline} - Decline incoming task
+ *   - {@link end} - End active task
+ * - Media Controls:
+ *   - {@link toggleMute} - Mute/unmute microphone for voice tasks
+ *   - {@link hold} - Place task on hold
+ *   - {@link resume} - Resume held task
+ * - Recording Controls:
+ *   - {@link pauseRecording} - Pause task recording
+ *   - {@link resumeRecording} - Resume paused recording
+ * - Task Transfer & Consultation:
+ *   - {@link consult} - Initiate consultation with another agent/queue
+ *   - {@link endConsult} - End ongoing consultation
+ *   - {@link transfer} - Transfer task to another agent/queue
+ *   - {@link consultTransfer} - Transfer after consultation
+ * - Task Completion:
+ *   - {@link wrapup} - Complete task wrap-up
+ *
+ * Key events emitted by Task instances (see {@link TASK_EVENTS} for details):
+ *
+ * - Task Lifecycle:
+ *   - task:incoming — New task is being offered
+ *   - task:assigned — Task assigned to agent
+ *   - task:unassigned — Task unassigned from agent
+ *   - task:end — Task has ended
+ *   - task:wrapup — Task entered wrap-up state
+ *   - task:wrappedup — Task wrap-up completed
+ *   - task:rejected — Task was rejected/unanswered
+ *   - task:hydrate — Task data populated
+ *
+ * - Media & Controls:
+ *   - task:media — Voice call media track received
+ *   - task:hold — Task placed on hold
+ *   - task:unhold — Task resumed from hold
+ *
+ * - Consultation & Transfer:
+ *   - task:consultCreated — Consultation initiated
+ *   - task:consulting — Consultation in progress
+ *   - task:consultAccepted — Consultation accepted
+ *   - task:consultEnd — Consultation ended
+ *   - task:consultQueueCancelled — Queue consultation cancelled
+ *   - task:consultQueueFailed — Queue consultation failed
+ *   - task:offerConsult — Consultation offered
+ *   - task:offerContact — New contact offered
+ *
+ * - Recording:
+ *   - task:recordingPaused — Recording paused
+ *   - task:recordingPauseFailed — Recording pause failed
+ *   - task:recordingResumed — Recording resumed
+ *   - task:recordingResumeFailed — Recording resume failed
+ *
+ * @implements {ITask}
+ * @example
+ * ```typescript
+ * // 1. Initialize task
+ * const task = new Task(contact, webCallingService, taskData);
+ *
+ * // 2. Set up event listeners
+ * task.on('task:media', (track) => {
+ *   // Handle voice call media
+ *   const audioElement = document.getElementById('remote-audio');
+ *   audioElement.srcObject = new MediaStream([track]);
+ * });
+ *
+ * task.on('task:hold', () => {
+ *   console.log('Task is on hold');
+ *   // Update UI to show hold state
+ * });
+ *
+ * task.on('task:end', () => {
+ *   console.log('Task ended');
+ *   if (task.data.wrapUpRequired) {
+ *     // Show wrap-up form
+ *   }
+ * });
+ *
+ * // 3. Example task operations
+ * await task.accept(); // Accept incoming task
+ * await task.hold();   // Place on hold
+ * await task.resume(); // Resume from hold
+ * await task.end();    // End task
+ *
+ * // 4. Handle wrap-up if required
+ * await task.wrapup({
+ *   auxCodeId: 'RESOLVED',
+ *   wrapUpReason: 'Customer issue resolved'
+ * });
+ * ```
+ */
+export default class Task extends EventEmitter implements ITask {
+    private contact;
+    private localAudioStream;
+    private webCallingService;
+    data: TaskData;
+    private metricsManager;
+    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
+     * @param webCallingService - The web calling service instance
+     * @param data - Initial task data
+     * @param wrapupData - Wrap-up configuration data
+     */
+    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
+     */
+    private setupAutoWrapupTimer;
+    /**
+     * Cancels the automatic wrap-up timer if it's running
+     * @public - Public so it can be called externally when needed
+     * Note: This is supported only in single session mode. Not supported in multi-session mode.
+     */
+    cancelAutoWrapupTimer(): void;
+    /**
+     * @ignore
+     * @private
+     */
+    private handleRemoteMedia;
+    /**
+     * @ignore
+     * @private
+     */
+    private registerWebCallListeners;
+    /**
+     * @ignore
+     */
+    unregisterWebCallListeners(): void;
+    /**
+     * Updates the task data with new information
+     * @param updatedData - New task data to merge with existing data
+     * @param shouldOverwrite - If true, completely replace data instead of merging
+     * @returns The updated task instance
+     * @example
+     * ```typescript
+     * task.updateTaskData(newData);
+     * task.updateTaskData(newData, true); // completely replace data
+     * ```
+     */
+    updateTaskData: (updatedData: TaskData, shouldOverwrite?: boolean) => this;
+    /**
+     * Recursively merges old data with new data
+     * @private
+     */
+    private reconcileData;
+    /**
+     * Agent accepts the incoming task.
+     * After accepting, the task will emit task:assigned event and for voice calls,
+     * a task:media event with the audio stream.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error if accepting task fails or media requirements not met
+     * @example
+     * ```typescript
+     * // Set up event handlers before accepting
+     * task.on(TASK_EVENTS.TASK_ASSIGNED, () => {
+     *   console.log('Task assigned, ID:', task.data.interactionId);
+     *   // Update UI to show active task
+     * });
+     *
+     * // For voice calls, handle media
+     * task.on(TASK_EVENTS.TASK_MEDIA, (track) => {
+     *   const audioElement = document.getElementById('remote-audio');
+     *   audioElement.srcObject = new MediaStream([track]);
+     * });
+     *
+     * // Accept the task
+     * try {
+     *   await task.accept();
+     *   console.log('Successfully accepted task');
+     * } catch (error) {
+     *   console.error('Failed to accept task:', error);
+     *   // Handle error (e.g., show error message to agent)
+     * }
+     * ```
+     */
+    accept(): Promise<TaskResponse>;
+    /**
+     * Agent can mute/unmute their microphone during a WebRTC task.
+     * This method toggles between muted and unmuted states for the local audio stream.
+     *
+     * @returns Promise<void> - Resolves when mute/unmute operation completes
+     * @throws Error if toggling mute state fails or audio stream is not available
+     * @example
+     * ```typescript
+     * // Toggle mute state
+     * task.toggleMute()
+     *   .then(() => console.log('Mute state toggled successfully'))
+     *   .catch(error => console.error('Failed to toggle mute:', error));
+     * ```
+     */
+    toggleMute(): Promise<void>;
+    /**
+     * Declines the incoming task. This will reject the task and notify the routing system.
+     * For voice calls, this is equivalent to declining the incoming call.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error if the decline operation fails
+     * @example
+     * ```typescript
+     * // Decline an incoming task
+     * task.decline()
+     *   .then(() => console.log('Task declined successfully'))
+     *   .catch(error => console.error('Failed to decline task:', error));
+     * ```
+     */
+    decline(): Promise<TaskResponse>;
+    /**
+     * Puts the current task/interaction on hold.
+     * Emits task:hold event when successful. For voice tasks, this mutes the audio.
+     *
+     * @param mediaResourceId - Optional media resource ID to use for the hold operation. If not provided, uses the task's current mediaResourceId
+     * @returns Promise<TaskResponse>
+     * @throws Error if hold operation fails
+     * @example
+     * ```typescript
+     * // Set up hold event handler
+     * task.on(TASK_EVENTS.TASK_HOLD, () => {
+     *   console.log('Task is now on hold');
+     *   // Update UI to show hold state (e.g., enable resume button, show hold indicator)
+     *   document.getElementById('resume-btn').disabled = false;
+     *   document.getElementById('hold-indicator').style.display = 'block';
+     * });
+     *
+     * // Place task on hold
+     * try {
+     *   await task.hold();
+     *   console.log('Successfully placed task on hold');
+     * } catch (error) {
+     *   console.error('Failed to place task on hold:', error);
+     *   // Handle error (e.g., show error message, reset UI state)
+     * }
+     *
+     * // Place task on hold with custom mediaResourceId
+     * try {
+     *   await task.hold('custom-media-resource-id');
+     *   console.log('Successfully placed task on hold with custom mediaResourceId');
+     * } catch (error) {
+     *   console.error('Failed to place task on hold:', error);
+     * }
+     * ```
+     */
+    hold(mediaResourceId?: string): Promise<TaskResponse>;
+    /**
+     * Resumes the task/interaction that was previously put on hold.
+     * Emits task:resume event when successful. For voice tasks, this restores the audio.
+     *
+     * @param mediaResourceId - Optional media resource ID to use for the resume operation. If not provided, uses the task's current mediaResourceId from interaction media
+     * @returns Promise<TaskResponse>
+     * @throws Error if resume operation fails
+     * @example
+     * ```typescript
+     * // Set up resume event handler
+     * task.on(TASK_EVENTS.TASK_RESUME, () => {
+     *   console.log('Task resumed from hold');
+     *   // Update UI to show active state
+     *   document.getElementById('hold-btn').disabled = false;
+     *   document.getElementById('hold-indicator').style.display = 'none';
+     * });
+     *
+     * // Resume task from hold
+     * try {
+     *   await task.resume();
+     *   console.log('Successfully resumed task from hold');
+     * } catch (error) {
+     *   console.error('Failed to resume task:', error);
+     *   // Handle error (e.g., show error message)
+     * }
+     *
+     * // Resume task from hold with custom mediaResourceId
+     * try {
+     *   await task.resume('custom-media-resource-id');
+     *   console.log('Successfully resumed task from hold with custom mediaResourceId');
+     * } catch (error) {
+     *   console.error('Failed to resume task:', error);
+     * }
+     * ```
+     */
+    resume(mediaResourceId?: string): Promise<TaskResponse>;
+    /**
+     * Ends the task/interaction with the customer.
+     * Emits task:end event when successful. If task requires wrap-up,
+     * this will be indicated in the task:end event data.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error if ending task fails
+     * @example
+     * ```typescript
+     * // Set up task end event handler
+     * task.on(TASK_EVENTS.TASK_END, (data) => {
+     *   console.log('Task ended:', task.data.interactionId);
+     *
+     *   if (data.wrapUpRequired) {
+     *     // Show wrap-up form
+     *     showWrapupForm();
+     *   } else {
+     *     // Clean up and prepare for next task
+     *     cleanupTask();
+     *   }
+     * });
+     *
+     * // End the task
+     * try {
+     *   await task.end();
+     *   console.log('Task end request successful');
+     * } catch (error) {
+     *   console.error('Failed to end task:', error);
+     *   // Handle error (e.g., show error message, retry option)
+     * }
+     *
+     * function showWrapupForm() {
+     *   // Show wrap-up UI with required codes
+     *   document.getElementById('wrapup-form').style.display = 'block';
+     * }
+     *
+     * function cleanupTask() {
+     *   // Reset UI state
+     *   document.getElementById('active-task').style.display = 'none';
+     *   document.getElementById('controls').style.display = 'none';
+     * }
+     * ```
+     */
+    end(): Promise<TaskResponse>;
+    /**
+     * Wraps up the task/interaction with the customer.
+     * This is called after task:end event if wrapUpRequired is true.
+     * Emits task:wrappedup event when successful.
+     *
+     * @param wrapupPayload - WrapupPayLoad containing:
+     *   - auxCodeId: Required ID for the wrap-up code
+     *   - wrapUpReason: Required description of wrap-up reason
+     * @returns Promise<TaskResponse>
+     * @throws Error if task data is unavailable, auxCodeId is missing, or wrapUpReason is missing
+     * @example
+     * ```typescript
+     * // Set up wrap-up events
+     * task.on(TASK_EVENTS.TASK_WRAPUP, () => {
+     *   console.log('Task ready for wrap-up');
+     *   // Show wrap-up form
+     *   document.getElementById('wrapup-form').style.display = 'block';
+     * });
+     *
+     * task.on(TASK_EVENTS.TASK_WRAPPEDUP, () => {
+     *   console.log('Task wrap-up completed');
+     *   // Clean up UI
+     *   document.getElementById('wrapup-form').style.display = 'none';
+     * });
+     *
+     * // Submit wrap-up
+     * try {
+     *   const wrapupPayload = {
+     *     auxCodeId: selectedCode, // e.g., 'ISSUE_RESOLVED'
+     *     wrapUpReason: 'Customer issue resolved successfully'
+     *   };
+     *   await task.wrapup(wrapupPayload);
+     *   console.log('Successfully submitted wrap-up');
+     * } catch (error) {
+     *   console.error('Failed to submit wrap-up:', error);
+     *   // Handle validation errors
+     *   if (error.message.includes('required')) {
+     *     // Show validation error to agent
+     *   }
+     * }
+     * ```
+     */
+    wrapup(wrapupPayload: WrapupPayLoad): Promise<TaskResponse>;
+    /**
+     * Pauses the recording for the current voice task.
+     * Emits task:recordingPaused event when successful.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error if pause recording fails
+     * @example
+     * ```typescript
+     * // Set up recording events
+     * task.on(TASK_EVENTS.TASK_RECORDING_PAUSED, () => {
+     *   console.log('Recording paused');
+     *   // Update UI to show recording paused state
+     *   document.getElementById('recording-status').textContent = 'Recording Paused';
+     *   document.getElementById('pause-recording-btn').style.display = 'none';
+     *   document.getElementById('resume-recording-btn').style.display = 'block';
+     * });
+     *
+     * task.on(TASK_EVENTS.TASK_RECORDING_PAUSE_FAILED, (error) => {
+     *   console.error('Failed to pause recording:', error);
+     *   // Show error to agent
+     * });
+     *
+     * // Pause recording
+     * try {
+     *   await task.pauseRecording();
+     *   console.log('Pause recording request sent');
+     * } catch (error) {
+     *   console.error('Error sending pause recording request:', error);
+     *   // Handle error
+     * }
+     * ```
+     */
+    pauseRecording(): Promise<TaskResponse>;
+    /**
+     * Resumes the recording for the voice task that was previously paused.
+     * Emits task:recordingResumed event when successful.
+     *
+     * @param resumeRecordingPayload - Configuration for resuming recording:
+     *   - autoResumed: Indicates if resume was automatic (defaults to false)
+     * @returns Promise<TaskResponse>
+     * @throws Error if resume recording fails
+     * @example
+     * ```typescript
+     * // Set up recording resume events
+     * task.on(TASK_EVENTS.TASK_RECORDING_RESUMED, () => {
+     *   console.log('Recording resumed');
+     *   // Update UI to show active recording state
+     *   document.getElementById('recording-status').textContent = 'Recording Active';
+     *   document.getElementById('pause-recording-btn').style.display = 'block';
+     *   document.getElementById('resume-recording-btn').style.display = 'none';
+     * });
+     *
+     * task.on(TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, (error) => {
+     *   console.error('Failed to resume recording:', error);
+     *   // Show error to agent
+     * });
+     *
+     * // Resume recording
+     * try {
+     *   const resumePayload = {
+     *     autoResumed: false // Set to true if triggered by system
+     *   };
+     *   await task.resumeRecording(resumePayload);
+     *   console.log('Resume recording request sent');
+     * } catch (error) {
+     *   console.error('Error sending resume recording request:', error);
+     *   // Handle error
+     * }
+     * ```
+     */
+    resumeRecording(resumeRecordingPayload: ResumeRecordingPayload): Promise<TaskResponse>;
+    /**
+     * Consults another agent or queue on an ongoing task for further assistance.
+     * During consultation, the original customer is typically placed on hold while
+     * the agent seeks guidance from another agent or queue.
+     *
+     * @param consultPayload - Configuration for the consultation containing:
+     *   - to: ID of the agent or queue to consult with
+     *   - destinationType: Type of destination (AGENT, QUEUE, etc.)
+     *   - holdParticipants: Whether to hold other participants (defaults to true)
+     * @returns Promise<TaskResponse> - Resolves with consultation result
+     * @throws Error if consultation fails or invalid parameters provided
+     * @example
+     * ```typescript
+     * // Consult with another agent
+     * const consultPayload = {
+     *   to: 'agentId123',
+     *   destinationType: DESTINATION_TYPE.AGENT,
+     *   holdParticipants: true
+     * };
+     * task.consult(consultPayload)
+     *   .then(response => console.log('Consultation started successfully'))
+     *   .catch(error => console.error('Failed to start consultation:', error));
+     *
+     * // Consult with a queue
+     * const queueConsultPayload = {
+     *   to: 'salesQueue123',
+     *   destinationType: DESTINATION_TYPE.QUEUE
+     * };
+     * task.consult(queueConsultPayload)
+     *   .then(response => console.log('Queue consultation started'))
+     *   .catch(error => console.error('Failed to start queue consultation:', error));
+     * ```
+     */
+    consult(consultPayload: ConsultPayload): Promise<TaskResponse>;
+    /**
+     * Ends an ongoing consultation session for the task.
+     * This terminates the consultation while maintaining the original customer connection.
+     *
+     * @param consultEndPayload - Configuration for ending the consultation containing:
+     *   - isConsult: Must be true to indicate this is a consultation end
+     *   - taskId: ID of the task being consulted on
+     *   - queueId: (Optional) Queue ID if this was a queue consultation
+     *   - isSecondaryEpDnAgent: (Optional) Indicates if this involves a secondary entry point
+     * @returns Promise<TaskResponse> - Resolves when consultation is ended
+     * @throws Error if ending consultation fails or invalid parameters provided
+     * @example
+     * ```typescript
+     * // End a direct agent consultation
+     * const consultEndPayload = {
+     *   isConsult: true,
+     *   taskId: 'task123'
+     * };
+     * task.endConsult(consultEndPayload)
+     *   .then(response => console.log('Consultation ended successfully'))
+     *   .catch(error => console.error('Failed to end consultation:', error));
+     *
+     * // End a queue consultation
+     * const queueConsultEndPayload = {
+     *   isConsult: true,
+     *   taskId: 'task123',
+     *   queueId: 'queue123'
+     * };
+     * task.endConsult(queueConsultEndPayload)
+     *   .then(response => console.log('Queue consultation ended'))
+     *   .catch(error => console.error('Failed to end queue consultation:', error));
+     * ```
+     */
+    endConsult(consultEndPayload: ConsultEndPayload): Promise<TaskResponse>;
+    /**
+     * Transfer the task to an agent directly or to a queue.
+     * This is a blind transfer that immediately redirects the task to the specified destination.
+     *
+     * @param transferPayload - Transfer configuration containing:
+     *   - to: ID of the agent or queue to transfer to
+     *   - destinationType: Type of destination (AGENT, QUEUE, etc.)
+     * @returns Promise<TaskResponse> - Resolves when transfer is completed
+     * @throws Error if transfer fails or invalid parameters provided
+     * @example
+     * ```typescript
+     * // Transfer to a queue
+     * const queueTransferPayload = {
+     *   to: 'salesQueue123',
+     *   destinationType: DESTINATION_TYPE.QUEUE
+     * };
+     * task.transfer(queueTransferPayload)
+     *   .then(response => console.log('Task transferred to queue successfully'))
+     *   .catch(error => console.error('Failed to transfer to queue:', error));
+     *
+     * // Transfer to an agent
+     * const agentTransferPayload = {
+     *   to: 'agentId123',
+     *   destinationType: DESTINATION_TYPE.AGENT
+     * };
+     * task.transfer(agentTransferPayload)
+     *   .then(response => console.log('Task transferred to agent successfully'))
+     *   .catch(error => console.error('Failed to transfer to agent:', error));
+     * ```
+     */
+    transfer(transferPayload: TransferPayLoad): Promise<TaskResponse>;
+    /**
+     * Transfer the task to the party that was consulted.
+     * This completes a consultative transfer where the agent first consulted with the target
+     * before transferring the task. For queue consultations, the transfer is automatically
+     * directed to the agent who accepted the consultation.
+     *
+     * @param consultTransferPayload - Configuration for the consultation transfer containing:
+     *   - to: ID of the agent or queue to transfer to
+     *   - destinationType: Type of destination (AGENT, QUEUE, etc. from CONSULT_TRANSFER_DESTINATION_TYPE)
+     * @returns Promise<TaskResponse> - Resolves when consultation transfer is completed
+     * @throws Error if transfer fails, no agent has accepted a queue consultation, or other validation errors
+     * @example
+     * ```typescript
+     * // Complete consultation transfer to an agent
+     * const agentConsultTransfer = {
+     *   to: 'agentId123',
+     *   destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT
+     * };
+     * task.consultTransfer(agentConsultTransfer)
+     *   .then(response => console.log('Consultation transfer to agent completed'))
+     *   .catch(error => console.error('Failed to complete agent consultation transfer:', error));
+     *
+     * // Complete consultation transfer to a queue agent
+     * const queueConsultTransfer = {
+     *   to: 'queue123',
+     *   destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE
+     * };
+     * task.consultTransfer(queueConsultTransfer)
+     *   .then(response => console.log('Consultation transfer to queue agent completed'))
+     *   .catch(error => console.error('Failed to complete queue consultation transfer:', error));
+     * ```
+     */
+    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>;
+    /**
+     * Transfers the current conference to another agent
+     *
+     * Moves the entire conference (including all participants) to a new agent,
+     * while the current agent exits and goes to wrapup
+     * On success, the current agent receives `task:conferenceEnded` event
+     *
+     * @returns Promise<TaskResponse> - Response from the conference transfer API
+     * @throws Error if the operation fails or if no active conference exists
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await task.transferConference();
+     *   console.log('Conference transferred successfully');
+     * } catch (error) {
+     *   console.error('Failed to transfer conference:', error);
+     * }
+     * ```
+     */
+    transferConference(): Promise<TaskResponse>;
+}