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

package/dist/types/cc.d.ts

@@ -0,0 +1,801 @@
+/**
+ * @module CCPlugin
+ * @packageDocumentation
+ * Contact Center Plugin module that provides functionality for managing contact center agents,
+ * handling tasks, and interacting with contact center services. This module enables integration
+ * with Webex Contact Center features through the WebexSDK.
+ */
+import { WebexPlugin } from '@webex/webex-core';
+import { SetStateResponse, IContactCenter, AgentLogin, AgentProfileUpdate, StationLoginResponse, StationLogoutResponse, BuddyAgentsResponse, BuddyAgents, UploadLogsResponse, UpdateDeviceTypeResponse } from './types';
+import LoggerProxy from './logger-proxy';
+import { StateChange, Logout } from './services/agent/types';
+import { Profile, OutdialAniEntriesResponse, OutdialAniParams } from './services/config/types';
+import { TaskResponse, PreviewContactPayload } from './services/task/types';
+import { AddressBook } from './services/AddressBook';
+import { ApiAIAssistant } from './services/ApiAiAssistant';
+import type { EntryPointListResponse, EntryPointSearchParams, ContactServiceQueuesResponse, ContactServiceQueueSearchParams } from './types';
+/**
+ * The main Contact Center plugin class that enables integration with Webex Contact Center.
+ *
+ * @class ContactCenter
+ * @extends WebexPlugin
+ * @implements IContactCenter
+ * @description
+ * Features:
+ *
+ * 1. Session Management:
+ *   - {@link register} - Initialize and register SDK with contact center
+ *   - {@link deregister} - Cleanup and disconnect SDK resources
+ *
+ * 2. Agent Login/Logout:
+ *   - {@link stationLogin} - Login with browser or desk phone
+ *   - {@link stationLogout} - Logout from current station
+ *   - {@link updateAgentProfile} - Update device type and settings
+ *
+ * 3. Agent State Control:
+ *   - {@link setAgentState} - Change agent state (Available/Idle)
+ *
+ * 4. Task Management:
+ *   - Inbound task handling via events
+ *   - {@link startOutdial} - Make outbound calls
+ *
+ * 5. Routing & Distribution:
+ *   - {@link getQueues} - Get available queues for routing
+ *   - {@link getBuddyAgents} - Get available buddy agents
+ *
+ * 6. Diagnostics:
+ *   - {@link uploadLogs} - Upload logs for troubleshooting
+ *
+ *  * Key Events:
+ * - Agent State Events:
+ *   - `agent:stateChange` - Agent's state has changed (Available, Idle, etc.)
+ *   - `agent:stateChangeSuccess` - Agent state change was successful
+ *   - `agent:stateChangeFailed` - Agent state change failed
+ *
+ * - Session Events:
+ *   - `agent:stationLoginSuccess` - Agent login was successful
+ *   - `agent:stationLoginFailed` - Agent login failed
+ *   - `agent:logoutSuccess` - Agent logout was successful
+ *   - `agent:logoutFailed` - Agent logout failed
+ *
+ * - Task Events:
+ *   - `task:incoming` - New task is being offered
+ *   - `task:hydrate` - Task data has been updated
+ *   - `task:established` - Task/call has been connected
+ *   - `task:ended` - Task/call has ended
+ *   - `task:error` - An error occurred during task handling
+ *   - `task:campaignPreviewReservation` - Campaign preview contact offered to agent
+ *
+ * @public
+ *
+ * @example
+ * ```typescript
+ * import Webex from 'webex';
+ *
+ * // Initialize SDK with access token
+ * const webex = new Webex({
+ *   credentials: 'YOUR_ACCESS_TOKEN'
+ * });
+ *
+ * // Get Contact Center plugin instance
+ * const cc = webex.cc;
+ *
+ * // Setup event handlers
+ * cc.on('agent:stateChange', (event) => {
+ *   console.log('Agent state changed:', event.state);
+ * });
+ *
+ * cc.on('task:incoming', (task) => {
+ *   console.log('New task received:', task.interactionId);
+ * });
+ *
+ * // Initialize agent session
+ * async function initializeAgent() {
+ *   try {
+ *     // Register with contact center
+ *     const profile = await cc.register();
+ *
+ *     // Login with browser-based calling
+ *     await cc.stationLogin({
+ *       teamId: profile.teams[0].teamId,
+ *       loginOption: 'BROWSER'
+ *     });
+ *
+ *     // Set agent to Available state
+ *     await cc.setAgentState({
+ *       state: 'Available',
+ *       auxCodeId: '0'
+ *     });
+ *
+ *     console.log('Agent initialized and ready');
+ *   } catch (error) {
+ *     console.error('Initialization failed:', error);
+ *     await cc.uploadLogs();  // Upload logs for troubleshooting
+ *   }
+ * }
+ *
+ * initializeAgent();
+ * ```
+ *
+ * @public
+ */
+export default class ContactCenter extends WebexPlugin implements IContactCenter {
+    /**
+     * The plugin's unique namespace identifier in the Webex SDK.
+     * Used to access the plugin via webex.cc
+     * @type {string}
+     * @public
+     */
+    namespace: string;
+    /**
+     * Plugin configuration settings including connection and authentication options
+     * @type {CCPluginConfig}
+     * @private
+     */
+    private $config;
+    /**
+     * Reference to the parent Webex SDK instance
+     * Used to access core Webex functionality and credentials
+     * @type {WebexSDK}
+     * @private
+     */
+    private $webex;
+    /**
+     * Event emitter for handling internal plugin events
+     * Manages event subscriptions and notifications
+     * @type {EventEmitter}
+     * @private
+     */
+    private eventEmitter;
+    /**
+     * Agent's profile and configuration data
+     * Includes capabilities, teams, settings, and current state
+     * @type {Profile}
+     * @private
+     */
+    private agentConfig;
+    /**
+     * Service for managing browser-based calling (WebRTC)
+     * Handles audio/video streaming and device management
+     * @type {WebCallingService}
+     * @private
+     */
+    private webCallingService;
+    /**
+     * Core service managers for Contact Center operations
+     * Includes agent, connection, and configuration services
+     * @type {Services}
+     * @private
+     */
+    private services;
+    /**
+     * Service for making authenticated HTTP requests to Webex APIs
+     * Handles request/response lifecycle and error handling
+     * @type {WebexRequest}
+     * @private
+     */
+    private webexRequest;
+    /**
+     * Manager for handling contact center tasks (calls, chats, etc.)
+     * Coordinates task lifecycle events and state
+     * @type {TaskManager}
+     * @private
+     */
+    private taskManager;
+    /**
+     * Manager for tracking and reporting SDK metrics and analytics
+     * Monitors performance, errors, and usage patterns
+     * @type {MetricsManager}
+     * @private
+     */
+    private metricsManager;
+    /**
+     * API instance for managing Webex Contact Center entry points
+     * Provides functionality to fetch entry points with caching support
+     * @type {EntryPoint}
+     * @public
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     * await cc.register();
+     * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+     *
+     * // Access EntryPointRecord
+     * const response = await cc.entryPoint.getEntryPoints({
+     *   page: 0,
+     *   pageSize: 50
+     * });
+     * ```
+     */
+    private entryPoint;
+    /**
+     * API instance for managing Webex Contact Center address book contacts
+     * Provides functionality to fetch address book entries with caching support
+     * @type {AddressBook}
+     * @public
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     * await cc.register();
+     * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+     *
+     * // Access AddressBook API
+     * const response = await cc.addressBook.getEntries({
+     *   page: 0,
+     *   pageSize: 25
+     * });
+     * ```
+     */
+    addressBook: AddressBook;
+    /**
+     * API instance for managing Webex Contact Center queues
+     * Provides functionality to fetch queues with caching support
+     * @type {Queue}
+     * @public
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     * await cc.register();
+     * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+     *
+     * // Access Queue API
+     * const response = await cc.queue.getQueues({
+     *   page: 0,
+     *   pageSize: 50
+     * });
+     *
+     * // Filter queues by specific criteria
+     * const filteredQueues = await cc.queue.getQueues({
+     *   filter: 'id=="queue-id-123"'
+     * });
+     * ```
+     */
+    private queue;
+    /**
+     * API instance for AI Assistant operations such as transcript controls.
+     * @type {ApiAIAssistant}
+     * @public
+     */
+    apiAIAssistant: ApiAIAssistant;
+    /**
+     * Logger utility for Contact Center plugin
+     * Provides consistent logging across the plugin
+     * @type {LoggerProxy}
+     * @public
+     */
+    LoggerProxy: typeof LoggerProxy;
+    /**
+     * @ignore
+     * Creates an instance of ContactCenter plugin
+     * @param {any[]} args Arguments passed to plugin constructor
+     */
+    constructor(...args: any[]);
+    /**
+     * Handles incoming task events and triggers appropriate notifications
+     * @private
+     * @param {ITask} task The incoming task object containing task details
+     */
+    private handleIncomingTask;
+    /**
+     * Handles task hydration events for updating task data
+     * @private
+     * @param {ITask} task The task object to be hydrated with additional data
+     */
+    private handleTaskHydrate;
+    /**
+     * Handles task merged events when tasks are combined eg: EPDN merge/transfer
+     * @private
+     * @param {ITask} task The task object that has been merged
+     */
+    private handleTaskMerged;
+    /**
+     * Handles campaign preview reservation events when a contact is offered to the agent
+     * @private
+     * @param {ITask} task The campaign reservation task
+     */
+    private handleCampaignPreviewReservation;
+    private handleRTDWebsocketMessage;
+    /**
+     * Sets up event listeners for incoming tasks and task hydration
+     * Subscribes to task events from the task manager
+     * @private
+     */
+    private incomingTaskListener;
+    /**
+     * Initializes the Contact Center SDK by setting up the web socket connections.
+     * This method must be called before performing any agent operations such as login, state change, or handling tasks.
+     *
+     * @returns {Promise<Profile>} Agent profile information after successful registration.
+     * The returned `Profile` object contains details such as:
+     * - `agentId`: The unique identifier for the agent.
+     * - `defaultDn`: The default dial number associated with the agent.
+     * - `teams`: Array of teams the agent belongs to.
+     * - `webRtcEnabled`: Indicates if WebRTC (browser calling) is enabled.
+     * - `loginVoiceOptions`: Supported login options for the agent (e.g., BROWSER, EXTENSION).
+     * - ...and other agent configuration details.
+     *
+     * @throws {Error} If registration fails.
+     *
+     * @public
+     * @example
+     * ```typescript
+     * import Webex from 'webex';
+     *
+     * const webex = Webex.init({ credentials: 'YOUR_ACCESS_TOKEN' });
+     * const cc = webex.cc;
+     *
+     * // Register the SDK and fetch agent profile
+     * const profile = await cc.register();
+     *
+     * console.log('Agent ID:', profile.agentId);
+     * console.log('Default DN:', profile.defaultDn);
+     * console.log('Teams:', profile.teams.map(t => t.teamId));
+     * console.log('WebRTC Enabled:', profile.webRtcEnabled);
+     * console.log('Supported Login Options:', profile.loginVoiceOptions);
+     *
+     * // Now you can proceed with station login, state changes, etc.
+     * await cc.stationLogin({ teamId: profile.teams[0].teamId, loginOption: 'BROWSER' });
+     * ```
+     */
+    register(): Promise<Profile>;
+    /**
+     * Unregisters the Contact Center SDK by closing all web socket connections, removing event listeners,
+     * and cleaning up internal state.
+     *
+     * @remarks
+     * This method only disconnects the SDK from the backend and cleans up resources. It does NOT perform a station logout
+     * (i.e., the agent remains logged in to the contact center unless you explicitly call {@link stationLogout}).
+     * Use this when you want to fully tear down the SDK instance, such as during application shutdown or user sign-out.
+     *
+     * @returns {Promise<void>} Resolves when deregistration and cleanup are complete.
+     * @throws {Error} If deregistration fails.
+     *
+     * @public
+     * @example
+     * // Typical usage: clean up SDK before application exit or user logout
+     * import Webex from 'webex';
+     *
+     * const webex = Webex.init({ credentials: 'YOUR_ACCESS_TOKEN' });
+     * const cc = webex.cc;
+     *
+     * await cc.register();
+     * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+     * // ... perform agent operations ...
+     *
+     * // If you want to log out the agent as well, call:
+     * // await cc.stationLogout({ logoutReason: 'User signed out' });
+     * // On application shutdown or user sign-out:
+     * await cc.deregister();
+     *
+  
+     */
+    deregister(): Promise<void>;
+    /**
+     * Returns the list of buddy agents who are in the given user state and media type based on their agent profile settings
+     * @param {BuddyAgents} data The data required to fetch buddy agents
+     * @returns {Promise<BuddyAgentsResponse>} A promise resolving to the buddy agents information
+     * @throws {Error} If fetching buddy agents fails
+     * @example
+     * ```typescript
+     * // Get list of available agents for consultation or transfer
+     * const cc = webex.cc;
+     *
+     * // First ensure you're registered and logged in
+     * await cc.register();
+     * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+     *
+     * // Get buddy agents filtered by state and media type
+     * const response = await cc.getBuddyAgents({
+     *   state: 'Available',     // Filter by agent state ('Available', 'Idle', etc.)
+     *   mediaType: 'telephony'  // Filter by media type ('telephony', 'chat', 'email', 'social')
+     * });
+     *
+     * // Process the buddy agents list
+     * if (response.data.agentList.length > 0) {
+     *   const buddyAgents = response.data.agentList;
+     *   console.log(`Found ${buddyAgents.length} available agents`);
+     *
+     *   // Access agent details
+     *   buddyAgents.forEach(agent => {
+     *     console.log(`Agent ID: ${agent.agentId}`);
+     *     console.log(`Name: ${agent.firstName} ${agent.lastName}`);
+     *     console.log(`State: ${agent.state}`);
+     *     console.log(`Team: ${agent.teamName}`);
+     *   });
+     * }
+     * ```
+     */
+    getBuddyAgents(data: BuddyAgents): Promise<BuddyAgentsResponse>;
+    /**
+     * Connects to the websocket and fetches the agent profile
+     * @returns {Promise<Profile>} Agent profile information
+     * @throws {Error} If connection fails or profile cannot be fetched
+     * @private
+     */
+    private connectWebsocket;
+    /**
+     * Performs agent login with specified credentials and device type
+     * @param {AgentLogin} data Login parameters including teamId, loginOption and dialNumber
+     * @returns {Promise<StationLoginResponse>} Response containing login status and profile
+     * @throws {Error} If login fails
+     * @public
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     * await cc.register();
+     *
+     * // Primary usage: using Promise response
+     * try {
+     *   const response = await cc.stationLogin({
+     *     teamId: 'team123',
+     *     loginOption: 'EXTENSION',
+     *     dialNumber: '1002'
+     *   });
+     *   console.log('Login successful:', response);
+     * } catch (error) {
+     *   console.error('Login failed:', error);
+     * }
+     *
+     * // Optional: Also listen for events elsewhere in your application
+     * // cc.on('agent:stationLoginSuccess', (data) => { ... });
+     * // cc.on('agent:stationLoginFailed', (error) => { ... });
+     * ```
+     */
+    stationLogin(data: AgentLogin): Promise<StationLoginResponse>;
+    /**
+     * Performs a station logout operation for the agent
+     * @remarks
+     * A logout operation cannot happen if the agent is in an interaction or haven't logged in yet.
+     * @param {Logout} data Logout parameters with logoutReason - a string explaining why the agent is logging out
+     * @returns {Promise<StationLogoutResponse>} Response indicating logout status
+     * @throws {Error} If logout fails
+     * @public
+     * @example
+     * ```typescript
+     * // Basic logout
+     * try {
+     *   await cc.stationLogout({
+     *     logoutReason: 'End of shift'
+     *   });
+     *   console.log('Logged out successfully');
+     * } catch (error) {
+     *   console.error('Logout failed:', error);
+     * }
+     * ```
+     */
+    stationLogout(data: Logout): Promise<StationLogoutResponse>;
+    /**
+     * Gets the device ID based on login option and dial number
+     * @param {string} loginOption The login option (BROWSER, EXTENSION, etc)
+     * @param {string} dialNumber The dial number if applicable
+     * @returns {string} The device ID
+     * @private
+     */
+    private getDeviceId;
+    /**
+     * Sets the state of the agent to Available or any of the Idle states.
+     * After a state change attempt, one of the following events will be emitted:
+     * - agent:stateChange: Emitted when agent's state changes (triggered for both local and remote changes)
+     * - agent:stateChangeSuccess: Emitted when agent state change is successful
+     * - agent:stateChangeFailed: Emitted when agent state change attempt fails
+     *
+     * @param {StateChange} data State change parameters including the new state
+     * @returns {Promise<SetStateResponse>} Response with updated state information
+     * @throws {Error} If state change fails
+     * @public
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     * await cc.register();
+     * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+     *
+     * // Using promise-based approach
+     * try {
+     *   await cc.setAgentState({
+     *     state: 'Available',
+     *     auxCodeId: '12345',
+     *     lastStateChangeReason: 'Manual state change',
+     *     agentId: 'agent123',
+     *   });
+     * } catch (error) {
+     *   console.error('State change failed:', error);
+     * }
+     *
+     * // Optionally, listen for events
+     * cc.on('agent:stateChange', (eventData) => {
+     *   // Triggered for both local and remote state changes
+     *   console.log('State changed:', eventData);
+     * });
+     *
+     * cc.on('agent:stateChangeSuccess', (eventData) => {
+     *   console.log('State change succeeded:', eventData);
+     * });
+     *
+     * cc.on('agent:stateChangeFailed', (error) => {
+     *   console.error('State change failed:', error);
+     * });
+     * ```
+     */
+    setAgentState(data: StateChange): Promise<SetStateResponse>;
+    /**
+     * Processes incoming websocket messages and emits corresponding events
+     * Handles various event types including agent state changes, login events,
+     * and other agent-related notifications
+     * @private
+     * @param {string} event The raw websocket event message
+     */
+    private handleWebsocketMessage;
+    /**
+     * Initializes event listeners for the Contact Center service
+     * Sets up handlers for connection state changes and other core events
+     * @private
+     */
+    private setupEventListeners;
+    /**
+     * Returns the connection configuration
+     * @returns {SubscribeRequest} Connection configuration
+     * @private
+     */
+    private getConnectionConfig;
+    /**
+     * Handles connection lost events and reconnection attempts
+     * @param {ConnectionLostDetails} msg Connection lost details
+     * @private
+     */
+    private handleConnectionLost;
+    /**
+     * Handles silent relogin after registration completion
+     * @private
+     */
+    private silentRelogin;
+    /**
+     * Handles device type specific configuration and setup
+     * Configures services and settings based on the login device type
+     * @param {LoginOption} deviceType The type of device being used for login
+     * @param {string} dn The dial number associated with the device
+     * @returns {Promise<void>}
+     * @private
+     */
+    private handleDeviceType;
+    /**
+     * Makes an outbound call to a specified phone number.
+     *
+     * @param {string} destination - The phone number to dial (e.g., '+1234567890').
+     * @param {string} origin - The contact center number that will be used while making a call to the customer.
+     * Should include country code and be in E.164 format.
+     * @returns {Promise<TaskResponse>} Resolves with the task response containing:
+     *   - interactionId: Unique identifier for the outbound call
+     *   - taskId: Identifier for the task instance
+     *   - data: Task details including state, queue info, and media properties
+     * @throws {Error} If the outdial operation fails:
+     *   - "Agent not configured for outbound calls" if isOutboundEnabledForAgent is false
+     *   - "Invalid phone number format" if destination is not in E.164 format
+     *   - "Agent not in Available state" if agent's state is not Available
+     * @public
+     * @example
+     * ```typescript
+     * // Initialize and prepare agent
+     * const cc = webex.cc;
+     * await cc.register();
+     * await cc.stationLogin({
+     *   teamId: 'team123',
+     *   loginOption: 'BROWSER'
+     * });
+     *
+     * // Set Available state before outbound call
+     * await cc.setAgentState({
+     *   state: 'Available',
+     *   auxCodeId: '0'
+     * });
+     *
+     * // Make outbound call with full error handling
+     * try {
+     *   // Verify agent is properly configured for outdial
+     *   if (!cc.agentConfig.isOutboundEnabledForAgent) {
+     *     throw new Error('Agent not configured for outbound calls');
+     *   }
+     *
+     *   // Start the outbound call
+     *   const destination = '+1234567890';
+     *   const task = await cc.startOutdial(destination, origin);
+     *
+     *   // Listen for all relevant task events
+     *   task.on('task:ringing', () => {
+     *     console.log('Call is ringing');
+     *     updateCallStatus('Ringing...');
+     *   });
+     *
+     *   task.on('task:established', () => {
+     *     console.log('Call connected');
+     *     updateCallStatus('Connected');
+     *     enableCallControls(); // Show mute, hold, transfer buttons
+     *   });
+     *
+     *   task.on('task:hold', () => {
+     *     console.log('Call placed on hold');
+     *     updateCallStatus('On Hold');
+     *   });
+     *
+     *   task.on('task:error', (error) => {
+     *     console.error('Call error:', error);
+     *     updateCallStatus('Error');
+     *     showErrorDialog(error.message);
+     *   });
+     *
+     *   task.on('task:ended', () => {
+     *     console.log('Call ended');
+     *     updateCallStatus('Call Ended');
+     *     resetCallControls();
+     *
+     *     // Handle wrap-up if required
+     *     if (task.data.wrapUpRequired) {
+     *       showWrapupForm();
+     *     }
+     *   });
+     *
+     *   // Example call control usage
+     *   function handleMuteToggle() {
+     *     await task.toggleMute();
+     *   }
+     *
+     *   function handleHoldToggle() {
+     *     if (task.data.isOnHold) {
+     *       await task.resume();
+     *     } else {
+     *       await task.hold();
+     *     }
+     *   }
+     *
+     *   async function handleTransfer() {
+     *     // Get available queues for transfer
+     *     const queues = await cc.getQueues();
+     *
+     *     // Transfer to first available queue
+     *     if (queues.length > 0) {
+     *       await task.transfer({
+     *         to: queues[0].queueId,
+     *         destinationType: 'QUEUE'
+     *       });
+     *     }
+     *   }
+     *
+     * } catch (error) {
+     *   console.error('Outdial failed:', error);
+     *   showErrorNotification('Failed to place call: ' + error.message);
+     * }
+     * ```
+     */
+    startOutdial(destination: string, origin: string): Promise<TaskResponse>;
+    /**
+     * Accepts a campaign preview contact, initiating the outbound call.
+     *
+     * When a campaign manager reserves a contact for an agent, the agent receives an
+     * `AgentOfferCampaignReservation` event. The agent can then accept the preview contact
+     * to initiate the outbound call.
+     *
+     * @param {PreviewContactPayload} payload - The preview contact payload containing interactionId and campaignId (campaign name, not UUID).
+     * @returns {Promise<TaskResponse>} Promise resolving with agent contact on success.
+     * @throws {Error} If the operation fails (network error, customer unavailable, etc.)
+     *
+     * @example
+     * ```typescript
+     * webex.cc.on('task:campaignPreviewReservation', async (task) => {
+     *   const { interactionId } = task.data;
+     *   // campaignId is the campaign name (e.g. "MyCampaign"), not a UUID
+     *   const campaignId = task.data.interaction.callProcessingDetails.campaignId;
+     *
+     *   const result = await webex.cc.acceptPreviewContact({ interactionId, campaignId });
+     * });
+     * ```
+     */
+    acceptPreviewContact(payload: PreviewContactPayload): Promise<TaskResponse>;
+    /**
+     * Fetches outdial ANI (Automatic Number Identification) entries for an outdial ANI ID.
+     *
+     * This method retrieves the list of phone numbers that can be used as caller ID when making
+     * outbound calls. The ANI data is associated with an outdial ANI ID and can be filtered
+     * and paginated as needed.
+     *
+     * @param {string} outdialANI - The outdial ANI ID to fetch ANI data for
+     * @param {number} [page] - Optional page number for pagination (0-based)
+     * @param {number} [pageSize] - Optional number of items per page
+     * @param {string} [search] - Optional search term to filter results by name or number
+     * @param {string} [filter] - Optional filter string
+     * @param {string} [attributes] - Optional attributes to include in response
+     * @returns {Promise<OutdialAniEntriesResponse>} Promise resolving to outdial ANI response containing:
+     *   - data: Array of ANI entries with number and name
+     *   - meta: Pagination metadata
+     * @throws {Error} If the operation fails or agent is not registered
+     * @public
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     * await cc.register();
+     *
+     * // Get agent profile to obtain outdial ANI ID
+     * const agentProfile = cc.agentConfig;
+     * const outdialANI = agentProfile.outdialANIId;
+     *
+     * // Basic usage - get all ANI data for an outdial ANI ID
+     * const aniData = await cc.getOutdialAniEntries({ outdialANI });
+     *
+     * // With pagination and search
+     * const paginatedAni = await cc.getOutdialAniEntries({
+     *   outdialANI,
+     *   page: 0,
+     *   pageSize: 50,
+     *   search: '555' // search for numbers containing '555'
+     * });
+     *
+     * // Process the results
+     * paginatedAni.forEach(ani => {
+     *   console.log(`ANI: ${ani.number} - ${ani.name}`);
+     * });
+     * ```
+     */
+    getOutdialAniEntries(params: OutdialAniParams): Promise<OutdialAniEntriesResponse>;
+    /**
+     * Uploads logs to help troubleshoot SDK issues.
+     *
+     * This method collects the current SDK logs including network requests, WebSocket
+     * messages, and client-side events, then securely submits them to Webex's diagnostics
+     * service. The returned tracking ID, feedbackID can be provided to Webex support for faster
+     * issue resolution.
+     * @returns Promise<UploadLogsResponse> Resolves with the upload logs response
+     * @throws Error If the upload fails
+     * @public
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     * try {
+     *   await cc.register();
+     * } catch (error) {
+     *   console.error('Error:', error);
+     *   const result = await cc.uploadLogs();
+     *   console.log('Logs uploaded. Tracking ID:', result.trackingId);
+     * }
+     * ```
+     */
+    uploadLogs(): Promise<UploadLogsResponse>;
+    /**
+     * Updates the agent device type and login configuration.
+     * Use this method to change how an agent connects to the contact center system (e.g., switching from browser-based calling to a desk phone extension).
+     * Change to any field of the profile is allowed;
+     *
+     * @param {AgentDeviceUpdate} data Configuration containing:
+     *   - loginOption: New device type ('BROWSER', 'EXTENSION', 'AGENT_DN')
+     *   - dialNumber: Required phone number when using EXTENSION or AGENT_DN
+     *   - teamId: Optional team ID (defaults to current team if not specified)
+     * @returns Promise<UpdateDeviceTypeResponse> Resolves with the device type update response
+     * @throws Error If the update fails
+     * @example
+     * ```typescript
+     * const cc = webex.cc;
+     *
+     * // Switch from browser to extension
+     * try {
+     *   await cc.updateAgentProfile({
+     *     loginOption: 'EXTENSION',
+     *     dialNumber: '1234',      // Required for EXTENSION
+     *     teamId: 'currentTeam'    // Optional: uses current team if not specified
+     *   });
+     * } catch (error) {
+     *   console.error('Failed to update device:', error.message);
+     * }
+     * ```
+     * @public
+     */
+    updateAgentProfile(data: AgentProfileUpdate): Promise<UpdateDeviceTypeResponse>;
+    /**
+     * Returns paginated entry points for the organization.
+     * Thin wrapper around internal EntryPoint instance.
+     * @public
+     */
+    getEntryPoints(params?: EntryPointSearchParams): Promise<EntryPointListResponse>;
+    /**
+     * Returns paginated contact service queues for the organization.
+     * Thin wrapper around internal Queue instance.
+     * @public
+     */
+    getQueues(params?: ContactServiceQueueSearchParams): Promise<ContactServiceQueuesResponse>;
+}