@webex/contact-center 3.9.0 → 3.10.0-multi-llms.1

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
@@ -226,6 +227,7 @@ export default class Task extends EventEmitter implements ITask {
      * 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
@@ -246,13 +248,22 @@ export default class Task extends EventEmitter implements ITask {
      *   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(): Promise<TaskResponse>;
+    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
@@ -273,9 +284,17 @@ export default class Task extends EventEmitter implements ITask {
      *   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(): Promise<TaskResponse>;
+    resume(mediaResourceId?: string): Promise<TaskResponse>;
     /**
      * Ends the task/interaction with the customer.
      * Emits task:end event when successful. If task requires wrap-up,
@@ -565,5 +584,67 @@ 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>;
+    /**
+     * 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>;
 }

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

@@ -334,7 +334,139 @@ 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",
+    /**
+     * 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"
 }
 /**
  * Represents a customer interaction within the contact center system
@@ -572,6 +704,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 */
@@ -594,6 +728,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;
 };
@@ -875,6 +1011,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 +1076,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 +1102,7 @@ export interface ITask extends EventEmitter {
      * @returns Promise<TaskResponse>
      * @example
      * ```typescript
-     * task.accept();
+     * await task.accept();
      * ```
      */
     accept(): Promise<TaskResponse>;
@@ -973,44 +1111,54 @@ 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"
      * });
@@ -1018,24 +1166,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.