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

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
@@ -572,6 +682,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 */
@@ -828,6 +940,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 +999,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
@@ -938,15 +1064,15 @@ 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;
@@ -964,7 +1090,7 @@ export interface ITask extends EventEmitter {
      * @returns Promise<TaskResponse>
      * @example
      * ```typescript
-     * task.accept();
+     * await task.accept();
      * ```
      */
     accept(): Promise<TaskResponse>;
@@ -973,44 +1099,44 @@ 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.
      * @returns Promise<TaskResponse>
      * @example
      * ```typescript
-     * task.hold();
+     * await task.hold();
      * ```
      */
     hold(): Promise<TaskResponse>;
     /**
-     * Resumes a task that was previously on hold
+     * Resumes a task that was previously on hold.
      * @returns Promise<TaskResponse>
      * @example
      * ```typescript
-     * task.resume();
+     * await task.resume();
      * ```
      */
     resume(): 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"
      * });
@@ -1018,24 +1144,100 @@ 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/dist/types/types.d.ts

@@ -1,6 +1,7 @@
 import { CallingClientConfig } from '@webex/calling';
 import * as Agent from './services/agent/types';
 import { Profile } from './services/config/types';
+import { PaginatedResponse, BaseSearchParams } from './utils/PageCache';
 /**
  * HTTP methods supported by WebexRequest.
  * @enum {string}
@@ -140,6 +141,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;
 }
 /**
  * Available logging severity levels.
@@ -434,6 +439,163 @@ export type StationReLoginResponse = Agent.ReloginSuccess | Error;
  * @ignore
  */
 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.

package/dist/types/utils/PageCache.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Common pagination metadata interface used across all APIs.
+ * @public
+ * @template T - Additional metadata properties specific to the API
+ */
+export interface PaginationMeta {
+    /** Organization ID */
+    orgid?: string;
+    /** Current page number */
+    page?: number;
+    /** Page size for current data set */
+    pageSize?: number;
+    /** Number of pages */
+    totalPages?: number;
+    /** Total number of items */
+    totalRecords?: number;
+    /** Total number of items (alias for compatibility) */
+    totalItems?: number;
+    /** Current page number (alias for compatibility) */
+    currentPage?: number;
+    /** Map of pagination links */
+    links?: Record<string, string>;
+}
+/**
+ * Common paginated response interface used across all APIs.
+ * @public
+ * @template T - The type of data items in the response
+ */
+export interface PaginatedResponse<T> {
+    /** Array of data items */
+    data: T[];
+    /** Pagination metadata */
+    meta: PaginationMeta;
+}
+/**
+ * Common search and pagination parameters interface.
+ * @public
+ */
+export interface BaseSearchParams {
+    /** Search keyword */
+    search?: string;
+    /** Filter criteria using RSQL syntax */
+    filter?: string;
+    /** Attributes to be returned */
+    attributes?: string;
+    /** Page number (starts from 0) */
+    page?: number;
+    /** Number of items per page */
+    pageSize?: number;
+    /** Sort field */
+    sortBy?: string;
+    /** Sort direction */
+    sortOrder?: 'asc' | 'desc';
+}
+/**
+ * Default pagination constants used across all APIs.
+ * @public
+ */
+export declare const PAGINATION_DEFAULTS: {
+    /** Default page number */
+    readonly PAGE: 0;
+    /** Default page size */
+    readonly PAGE_SIZE: 100;
+};
+/**
+ * Interface for cached page entry with metadata
+ * @public
+ */
+export interface PageCacheEntry<T> {
+    /** Cached data items for this page */
+    data: T[];
+    /** Timestamp when this page was cached */
+    timestamp: number;
+    /** Total metadata if available */
+    totalMeta?: {
+        totalPages?: number;
+        totalRecords?: number;
+    };
+}
+/**
+ * Interface for cache validation parameters
+ * @public
+ */
+export interface CacheValidationParams {
+    /** Search query parameter */
+    search?: string;
+    /** Filter parameter */
+    filter?: string;
+    /** Attributes parameter */
+    attributes?: string;
+    /** Sort by parameter */
+    sortBy?: string;
+}
+/**
+ * Page cache utility class for managing paginated API response caching.
+ * Provides consistent caching behavior across all Contact Center APIs.
+ *
+ * @class PageCache
+ * @public
+ * @template T - The type of data items being cached
+ * @example
+ * ```typescript
+ * // Create a cache instance for a specific data type
+ * const cache = new PageCache<AddressBookEntry>('AddressBook');
+ *
+ * // Check if we can use cache (no search/filter parameters)
+ * if (cache.canUseCache({ search, filter })) {
+ *   const cacheKey = cache.buildCacheKey(orgId, page, pageSize);
+ *   const cachedPage = cache.getCachedPage(cacheKey);
+ *
+ *   if (cachedPage) {
+ *     return cachedPage.data;
+ *   }
+ * }
+ *
+ * // Cache API response
+ * cache.cachePage(cacheKey, responseData, responseMeta);
+ * ```
+ */
+export declare class PageCache<T> {
+    private cache;
+    private apiName;
+    /**
+     * Creates an instance of PageCache
+     * @param {string} apiName - Name of the API using this cache (for logging)
+     * @public
+     */
+    constructor(apiName: string);
+    /**
+     * Checks if cache can be used for the given parameters.
+     * Cache is only used for simple pagination without search/filter/attributes/sort.
+     * @param {CacheValidationParams} params - Parameters to validate
+     * @returns {boolean} True if cache can be used
+     * @public
+     */
+    canUseCache(params: CacheValidationParams): boolean;
+    /**
+     * Builds a cache key for the given parameters
+     * @param {string} orgId - Organization ID
+     * @param {number} page - Page number
+     * @param {number} pageSize - Page size
+     * @returns {string} Cache key
+     * @public
+     */
+    buildCacheKey(orgId: string, page: number, pageSize: number): string;
+    /**
+     * Gets a cached page if it exists and is valid
+     * @param {string} cacheKey - Cache key to look up
+     * @returns {PageCacheEntry<T> | null} Cached page entry or null if not found/expired
+     * @public
+     */
+    getCachedPage(cacheKey: string): PageCacheEntry<T> | null;
+    /**
+     * Caches a page of data with metadata
+     * @param {string} cacheKey - Cache key
+     * @param {T[]} data - Data items to cache
+     * @param {any} meta - Metadata from API response
+     * @public
+     */
+    cachePage(cacheKey: string, data: T[], meta?: any): void;
+    /**
+     * Clears all cached entries
+     * @public
+     */
+    clearCache(): void;
+    /**
+     * Gets the current number of cached entries
+     * @returns {number} Number of cached entries
+     * @public
+     */
+    getCacheSize(): number;
+}
+export default PageCache;