@webex/contact-center 3.9.0 → 3.10.0-next.10

package/src/services/task/types.ts

@@ -370,6 +370,150 @@ export enum TASK_EVENTS {
    * ```
    */
   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',
+
+  /**
+   * Triggered when a contact is merged
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_MERGED, (task: ITask) => {
+   *   console.log('Contact merged:', task.data.interactionId);
+   *   // Handle contact merge
+   * });
+   * ```
+   */
+  TASK_MERGED = 'task:merged',
+
+  /**
+   * Triggered when a participant enters post-call activity state
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, (task: ITask) => {
+   *   console.log('Participant in post-call activity:', task.data.interactionId);
+   *   // Handle post-call activity
+   * });
+   * ```
+   */
+  TASK_POST_CALL_ACTIVITY = 'task:postCallActivity',
 }
 
 /**
@@ -613,6 +757,8 @@ export type TaskData = {
   isConsulted?: boolean;
   /** Indicates if the task is in conference state */
   isConferencing: boolean;
+  /** Indicates if a conference is currently in progress (2+ active agents) */
+  isConferenceInProgress?: boolean;
   /** Identifier of agent who last updated the task */
   updatedBy?: string;
   /** Type of destination for transfer/consult */
@@ -635,6 +781,8 @@ export type TaskData = {
   isWebCallMute?: boolean;
   /** Identifier for reservation interaction */
   reservationInteractionId?: string;
+  /** Identifier for the reserved agent channel (used for campaign tasks) */
+  reservedAgentChannelId?: string;
   /** Indicates if wrap-up is required for this task */
   wrapUpRequired?: boolean;
 };
@@ -931,6 +1079,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;
 };
 
 /**
@@ -1000,16 +1150,16 @@ export interface ITask extends EventEmitter {
   autoWrapup?: AutoWrapup;
 
   /**
-   * cancels the auto-wrapup timer for the task
-   * This method stops the auto-wrapup process if it is currently active
+   * Cancels the auto-wrapup timer for the task.
+   * This method stops the auto-wrapup process if it is currently active.
    * Note: This is supported only in single session mode. Not supported in multi-session mode.
    * @returns void
    */
   cancelAutoWrapupTimer(): void;
 
   /**
-   * Deregisters all web call event listeners
-   * Used when cleaning up task resources
+   * Deregisters all web call event listeners.
+   * Used when cleaning up task resources.
    * @ignore
    */
   unregisterWebCallListeners(): void;
@@ -1029,7 +1179,7 @@ export interface ITask extends EventEmitter {
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.accept();
+   * await task.accept();
    * ```
    */
   accept(): Promise<TaskResponse>;
@@ -1039,48 +1189,58 @@ export interface ITask extends EventEmitter {
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.decline();
+   * await task.decline();
    * ```
    */
   decline(): Promise<TaskResponse>;
 
   /**
-   * Places the current task on hold
+   * Places the current task on hold.
+   * @param mediaResourceId - Optional media resource ID to use for the hold operation. If not provided, uses the task's current mediaResourceId
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.hold();
+   * // Hold with default mediaResourceId
+   * await task.hold();
+   *
+   * // Hold with custom mediaResourceId
+   * await task.hold('custom-media-resource-id');
    * ```
    */
-  hold(): Promise<TaskResponse>;
+  hold(mediaResourceId?: string): Promise<TaskResponse>;
 
   /**
-   * Resumes a task that was previously on hold
+   * Resumes a task that was previously on hold.
+   * @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>
    * @example
    * ```typescript
-   * task.resume();
+   * // Resume with default mediaResourceId
+   * await task.resume();
+   *
+   * // Resume with custom mediaResourceId
+   * await task.resume('custom-media-resource-id');
    * ```
    */
-  resume(): Promise<TaskResponse>;
+  resume(mediaResourceId?: string): Promise<TaskResponse>;
 
   /**
-   * Ends/terminates the current task
+   * Ends/terminates the current task.
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.end();
+   * await task.end();
    * ```
    */
   end(): Promise<TaskResponse>;
 
   /**
-   * Initiates wrap-up process for the task with specified details
+   * Initiates wrap-up process for the task with specified details.
    * @param wrapupPayload - Wrap-up details including reason and auxiliary code
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.wrapup({
+   * await task.wrapup({
    *   wrapUpReason: "Customer issue resolved",
    *   auxCodeId: "RESOLVED"
    * });
@@ -1089,25 +1249,109 @@ export interface ITask extends EventEmitter {
   wrapup(wrapupPayload: WrapupPayLoad): Promise<TaskResponse>;
 
   /**
-   * Pauses the recording for current task
+   * Pauses the recording for current task.
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.pauseRecording();
+   * await task.pauseRecording();
    * ```
    */
   pauseRecording(): Promise<TaskResponse>;
 
   /**
-   * Resumes a previously paused recording
+   * Resumes a previously paused recording.
    * @param resumeRecordingPayload - Parameters for resuming the recording
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.resumeRecording({
+   * await task.resumeRecording({
    *   autoResumed: false
    * });
    * ```
    */
   resumeRecording(resumeRecordingPayload: ResumeRecordingPayload): Promise<TaskResponse>;
+
+  /**
+   * Initiates a consultation with another agent or queue.
+   * @param consultPayload - Consultation details including destination and type
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.consult({ to: "agentId", destinationType: "agent" });
+   * ```
+   */
+  consult(consultPayload: ConsultPayload): Promise<TaskResponse>;
+
+  /**
+   * Ends an ongoing consultation.
+   * @param consultEndPayload - Details for ending the consultation
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.endConsult({ isConsult: true, taskId: "taskId" });
+   * ```
+   */
+  endConsult(consultEndPayload: ConsultEndPayload): Promise<TaskResponse>;
+
+  /**
+   * Transfers the task to another agent or queue.
+   * @param transferPayload - Transfer details including destination and type
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.transfer({ to: "queueId", destinationType: "queue" });
+   * ```
+   */
+  transfer(transferPayload: TransferPayLoad): Promise<TaskResponse>;
+
+  /**
+   * Transfers the task after consultation.
+   * @param consultTransferPayload - Details for consult transfer (optional)
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.consultTransfer({ to: "agentId", destinationType: "agent" });
+   * ```
+   */
+  consultTransfer(consultTransferPayload?: ConsultTransferPayLoad): Promise<TaskResponse>;
+
+  /**
+   * Initiates a consult conference (merge consult call with main call).
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.consultConference();
+   * ```
+   */
+  consultConference(): Promise<TaskResponse>;
+
+  /**
+   * Exits from an ongoing conference.
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.exitConference();
+   * ```
+   */
+  exitConference(): Promise<TaskResponse>;
+
+  /**
+   * Transfers the conference to another participant.
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.transferConference();
+   * ```
+   */
+  transferConference(): Promise<TaskResponse>;
+
+  /**
+   * Toggles mute/unmute for the local audio stream during a WebRTC task.
+   * @returns Promise<void>
+   * @example
+   * ```typescript
+   * await task.toggleMute();
+   * ```
+   */
+  toggleMute(): Promise<void>;
 }

package/src/types.ts

@@ -7,6 +7,7 @@ import {
 import * as Agent from './services/agent/types';
 import * as Contact from './services/task/types';
 import {Profile} from './services/config/types';
+import {PaginatedResponse, BaseSearchParams} from './utils/PageCache';
 
 /**
  * Generic type for converting a const enum object into a union type of its values.
@@ -192,6 +193,10 @@ export interface LogContext {
   method?: string;
   interactionId?: string;
   trackingId?: string;
+  /** Additional structured data to include in logs */
+  data?: Record<string, any>;
+  /** Error object to include in logs */
+  error?: Error | unknown;
 }
 
 /**
@@ -620,6 +625,181 @@ export type StationReLoginResponse = Agent.ReloginSuccess | Error;
  */
 export type SetStateResponse = Agent.StateChangeSuccess | Error;
 
+/**
+ * AddressBook types
+ */
+export interface AddressBookEntry {
+  id: string;
+  organizationId?: string;
+  version?: number;
+  name: string;
+  number: string;
+  createdTime?: number;
+  lastUpdatedTime?: number;
+}
+
+export type AddressBookEntriesResponse = PaginatedResponse<AddressBookEntry>;
+
+export interface AddressBookEntrySearchParams extends BaseSearchParams {
+  addressBookId?: string;
+}
+
+/**
+ * EntryPointRecord types
+ */
+export interface EntryPointRecord {
+  id: string;
+  name: string;
+  description?: string;
+  type: string;
+  isActive: boolean;
+  orgId: string;
+  createdAt?: string;
+  updatedAt?: string;
+  settings?: Record<string, any>;
+}
+
+export type EntryPointListResponse = PaginatedResponse<EntryPointRecord>;
+export type EntryPointSearchParams = BaseSearchParams;
+
+/**
+ * Queue types
+ */
+export interface QueueSkillRequirement {
+  organizationId?: string;
+  id?: string;
+  version?: number;
+  skillId: string;
+  skillName?: string;
+  skillType?: string;
+  condition: string;
+  skillValue: string;
+  createdTime?: number;
+  lastUpdatedTime?: number;
+}
+
+export interface QueueAgent {
+  id: string;
+  ciUserId?: string;
+}
+
+export interface AgentGroup {
+  teamId: string;
+}
+
+export interface CallDistributionGroup {
+  agentGroups: AgentGroup[];
+  order: number;
+  duration?: number;
+}
+
+export interface AssistantSkillMapping {
+  assistantSkillId?: string;
+  assistantSkillUpdatedTime?: number;
+}
+
+/**
+ * Configuration for a contact service queue
+ * @public
+ */
+export interface ContactServiceQueue {
+  /** Organization ID */
+  organizationId?: string;
+  /** Unique identifier for the queue */
+  id?: string;
+  /** Version of the queue */
+  version?: number;
+  /** Name of the Contact Service Queue */
+  name: string;
+  /** Description of the queue */
+  description?: string;
+  /** Queue type (INBOUND, OUTBOUND) */
+  queueType: 'INBOUND' | 'OUTBOUND';
+  /** Whether to check agent availability */
+  checkAgentAvailability: boolean;
+  /** Channel type (TELEPHONY, EMAIL, SOCIAL_CHANNEL, CHAT, etc.) */
+  channelType: 'TELEPHONY' | 'EMAIL' | 'FAX' | 'CHAT' | 'VIDEO' | 'OTHERS' | 'SOCIAL_CHANNEL';
+  /** Social channel type for SOCIAL_CHANNEL channelType */
+  socialChannelType?:
+    | 'MESSAGEBIRD'
+    | 'MESSENGER'
+    | 'WHATSAPP'
+    | 'APPLE_BUSINESS_CHAT'
+    | 'GOOGLE_BUSINESS_MESSAGES';
+  /** Service level threshold in seconds */
+  serviceLevelThreshold: number;
+  /** Maximum number of simultaneous contacts */
+  maxActiveContacts: number;
+  /** Maximum time in queue in seconds */
+  maxTimeInQueue: number;
+  /** Default music in queue media file ID */
+  defaultMusicInQueueMediaFileId: string;
+  /** Timezone for routing strategies */
+  timezone?: string;
+  /** Whether the queue is active */
+  active: boolean;
+  /** Whether outdial campaign 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 recording is permitted */
+  pauseRecordingPermitted: boolean;
+  /** Recording pause duration in seconds */
+  recordingPauseDuration?: number;
+  /** Control flow script URL */
+  controlFlowScriptUrl: string;
+  /** IVR requeue URL */
+  ivrRequeueUrl: string;
+  /** Overflow number for telephony */
+  overflowNumber?: string;
+  /** Vendor ID */
+  vendorId?: string;
+  /** Routing type */
+  routingType: 'LONGEST_AVAILABLE_AGENT' | 'SKILLS_BASED' | 'CIRCULAR' | 'LINEAR';
+  /** Skills-based routing type */
+  skillBasedRoutingType?: 'LONGEST_AVAILABLE_AGENT' | 'BEST_AVAILABLE_AGENT';
+  /** Queue routing type */
+  queueRoutingType: 'TEAM_BASED' | 'SKILL_BASED' | 'AGENT_BASED';
+  /** Queue skill requirements */
+  queueSkillRequirements?: QueueSkillRequirement[];
+  /** List of agents for agent-based queue */
+  agents?: QueueAgent[];
+  /** Call distribution groups */
+  callDistributionGroups: CallDistributionGroup[];
+  /** XSP version */
+  xspVersion?: string;
+  /** Subscription ID */
+  subscriptionId?: string;
+  /** Assistant skill mapping */
+  assistantSkill?: AssistantSkillMapping;
+  /** Whether this is a system default queue */
+  systemDefault?: boolean;
+  /** User who last updated agents list */
+  agentsLastUpdatedByUserName?: string;
+  /** Email of user who last updated agents list */
+  agentsLastUpdatedByUserEmailPrefix?: string;
+  /** When agents list was last updated */
+  agentsLastUpdatedTime?: number;
+  /** Creation timestamp in epoch millis */
+  createdTime?: number;
+  /** Last updated timestamp in epoch millis */
+  lastUpdatedTime?: number;
+}
+
+export type ContactServiceQueuesResponse = PaginatedResponse<ContactServiceQueue>;
+
+export interface ContactServiceQueueSearchParams extends BaseSearchParams {
+  desktopProfileFilter?: boolean;
+  provisioningView?: boolean;
+  singleObjectResponse?: boolean;
+}
+
 /**
  * Response type for buddy agents query operations.
  * Either a success response with list of buddy agents or an error.