@webex/contact-center 3.12.0-next.13 → 3.12.0-next.130

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

@@ -0,0 +1,227 @@
+import routingContact from '../contact';
+import { ConsultPayload, ConsultEndPayload, ResumeRecordingPayload, TaskData, TaskResponse, DropConferenceParticipantPayload, IVoice, VoiceUIControlOptions, TaskToggleMuteOptions, TaskTransmitDtmfOptions, TransferPayLoad } from '../types';
+import Task from '../Task';
+import { TaskActionArgs } from '../state-machine';
+import { WrapupData } from '../../config/types';
+export default class Voice extends Task implements IVoice {
+    private static readonly WXAPP_MUTE_SYNC_RETRY_DELAY_MS;
+    private static readonly WXAPP_MUTE_SYNC_MAX_RETRIES;
+    private answerCallOnWebexService?;
+    private enableWxBetterTogether;
+    private wxAppMuted;
+    private wxAppAnswerPending;
+    private wxAppAcceptInFlight;
+    private wxAppMuteSyncInFlight?;
+    private wxAppMuteToggleTail;
+    private wxAppDtmfTail;
+    private lastLoggedWxAppAcceptReason?;
+    constructor(contact: ReturnType<typeof routingContact>, data: TaskData, callOptions?: VoiceUIControlOptions, wrapupData?: WrapupData, agentId?: string);
+    private getWxAppVoiceDependencies;
+    /** @deprecated Use {@link Voice.getWxAppVoiceDependencies} */
+    private getWxAppVoiceDeps;
+    isWebexAppCallingOffer(): boolean;
+    isWebexAppInboundCallingOffer(): boolean;
+    private setWxAppAnswerPending;
+    private setWxAppAcceptInFlight;
+    setEnableWxBetterTogether(enabled: boolean): void;
+    protected updateUiControls(forceEmit?: boolean): void;
+    private logWxAppOfferDecisionIfNeeded;
+    applyWxAppMuteStateFromSync(incomingCallId: string, muted: boolean): void;
+    getWxAppMuted(): boolean;
+    private static delay;
+    private canRetryWxAppMuteSync;
+    private shouldSkipWxAppMuteSync;
+    private applyWxAppMuteFromBackfill;
+    syncWxAppMuteFromCallDetails(retryAttempt?: number): Promise<boolean | undefined>;
+    private performWxAppMuteSync;
+    protected onTaskAssigned(): void;
+    protected onTaskHydrated(): void;
+    getCallingDeviceDetails(): import("../WebexCallingUtils").WebexCallingDeviceDetails;
+    getWebexCallingCallId(): string | null;
+    private createWxAppLifecycle;
+    private getStateMachineSnapshot;
+    /**
+     * Accepts the task. Routes to wxApp telephony answer when `enableWxBetterTogether` and wxApp offer.
+     */
+    accept(): Promise<TaskResponse>;
+    /**
+     * Declines the task. Routes wxApp inbound to telephony reject; wxApp outdial offer to cancelTask.
+     */
+    decline(): Promise<TaskResponse>;
+    /**
+     * Toggles mute for wxApp engaged telephony when `enableWxBetterTogether` is active.
+     */
+    toggleMute(options?: TaskToggleMuteOptions): Promise<void>;
+    /**
+     * Sends in-call DTMF for wxApp engaged telephony when `enableWxBetterTogether` is active.
+     */
+    transmitDtmf(options: TaskTransmitDtmfOptions): Promise<void>;
+    /**
+     * This is used to hold the task.
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.hold().then(()=>{}).catch(()=>{})
+     * ```
+     * */
+    hold(): Promise<TaskResponse>;
+    /**
+     * This is used to resume the task.
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.resume().then(()=>{}).catch(()=>{})
+     * ```
+     * */
+    resume(): Promise<TaskResponse>;
+    /**
+     * This is used to hold or resume the task.
+     * @param isHeld: boolean - true to hold the task, false to resume it
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.holdResume(isHeld: true).then(()=>{}).catch(()=>{})
+     * ```
+     * */
+    holdResume(): Promise<TaskResponse>;
+    /**
+     * This is used to pause the call recording
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.pauseRecording().then(()=>{}).catch(()=>{});
+     * ```
+     */
+    pauseRecording(): Promise<TaskResponse>;
+    /**
+     * This is used to pause the call recording
+     * @param resumeRecordingPayload
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.resumeRecording(resumeRecordingPayload).then(()=>{}).catch(()=>{});
+     * ```
+     */
+    resumeRecording(resumeRecordingPayload?: ResumeRecordingPayload): Promise<TaskResponse>;
+    /**
+     * This is used to consult the task
+     * @param consultPayload
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * const consultPayload = {
+     *   destination: 'myBuddyAgentId',
+     *   destinationType: DESTINATION_TYPE.AGENT,
+     * }
+     * task.consult(consultPayload).then(()=>{}).catch(()=>{});
+     * ```
+     * */
+    consult(consultPayload?: ConsultPayload): Promise<TaskResponse>;
+    /**
+     * This is used to end the consult session on the task.
+     * @param consultEndPayload - Payload indicating consult end flags and identifiers
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.endConsult({
+     *   isConsult: true,
+     *   queueId: 'myQueueId',
+     *   taskId: 'taskId',
+     * });
+     * ```
+     */
+    endConsult(consultEndPayload?: ConsultEndPayload): Promise<TaskResponse>;
+    /**
+     * This is used to transfer the task.
+     * @param payload - Transfer payload
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.transfer({
+     *   to: 'destinationId',
+     *   destinationType: DESTINATION_TYPE.AGENT,
+     *   consult: true, // Optional, if true will perform a consult transfer else blind transfer
+     * });
+     * ```
+     */
+    transfer(payload: TransferPayLoad): Promise<TaskResponse>;
+    /**
+     * Start a consult conference, merging main and consult calls.
+     */
+    consultConference(): Promise<TaskResponse>;
+    /**
+     * Removes another participant from an active conference.
+     * Completion is correlated with ParticipantLeftConference by the AQM request layer.
+     * @param payload - Participant identifier to remove
+     * @returns Promise<TaskResponse>
+     */
+    dropConferenceParticipant(payload: DropConferenceParticipantPayload): Promise<TaskResponse>;
+    /**
+     * Exit from a conference call.
+     * Per conference-spec.md:
+     * - Primary agent exits to wrapup
+     * - Non-primary agent exits to available/connected
+     * - Other participants continue the call
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error if not in conference or exit fails
+     * @example
+     * ```typescript
+     * task.exitConference().then(() => {}).catch(() => {});
+     * ```
+     */
+    exitConference(): Promise<TaskResponse>;
+    /**
+     * Transfer the conference to another participant.
+     * Per conference-spec.md: Only primary agent can transfer conference.
+     * After transfer, the transferring agent exits to wrapup.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error if not in conference or transfer fails
+     * @example
+     * ```typescript
+     * task.transferConference().then(() => {}).catch(() => {});
+     * ```
+     */
+    transferConference(): Promise<TaskResponse>;
+    /**
+     * Toggle between consult call and main call during consulting.
+     * If on consult leg (consultCallHeld = false), switches to main call by holding consult.
+     * If on main call (consultCallHeld = true), switches to consult by resuming consult.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error if not in CONSULTING state or no consult media resource
+     * @example
+     * ```typescript
+     * await task.switchCall();
+     * ```
+     */
+    switchCall(): Promise<TaskResponse>;
+    protected getChannelSpecificActionOverrides(): {
+        emitTaskHold: ({ event }: TaskActionArgs) => void;
+        emitTaskResume: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingStarted: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingPaused: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingPauseFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingResumed: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingResumeFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskParticipantJoined: ({ event }: TaskActionArgs) => void;
+        emitTaskParticipantLeft: ({ event }: TaskActionArgs) => void;
+        emitTaskConferenceStarted: ({ event }: TaskActionArgs) => void;
+        emitTaskConferenceEnded: ({ event }: TaskActionArgs) => void;
+        emitTaskConferenceFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskExitConference: ({ event }: TaskActionArgs) => void;
+        emitTaskTransferConference: ({ event }: TaskActionArgs) => void;
+        emitTaskSwitchCall: ({ event }: TaskActionArgs) => void;
+        emitTaskTransferConferenceFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskOutdialFailed: ({ event }: TaskActionArgs) => void;
+    };
+}

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

@@ -0,0 +1,53 @@
+import routingContact from '../contact';
+import { TaskData, TaskResponse, IWebRTC, VoiceUIControlOptions, TaskToggleMuteOptions } from '../types';
+import Voice from './Voice';
+import WebCallingService from '../../WebCallingService';
+import { WrapupData } from '../../config/types';
+export default class WebRTC extends Voice implements IWebRTC {
+    private localAudioStream;
+    private webCallingService;
+    constructor(contact: ReturnType<typeof routingContact>, webCallingService: WebCallingService, data: TaskData, callOptions?: VoiceUIControlOptions, wrapupData?: WrapupData, agentId?: string);
+    private registerWebCallListeners;
+    private handleRemoteMedia;
+    /**
+     * This method is used to unregister the web call listeners.
+     * @returns void
+     * @example
+     * ```typescript
+     * task.unregisterWebCallListeners();
+     * ```
+     */
+    unregisterWebCallListeners(): void;
+    /**
+     * This is used for incoming task accept by agent.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.accept().then(()=>{}).catch(()=>{})
+     * ```
+     */
+    accept(): Promise<TaskResponse>;
+    /**
+     * This is used for the incoming task decline by agent.
+     *
+     * @returns Promise<TaskResponse>
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.decline().then(()=>{}).catch(()=>{})
+     * ```
+     */
+    decline(): Promise<TaskResponse>;
+    /**
+     * This is used for the placing the call in mute or unmute by the agent.
+     *
+     * @throws Error
+     * @example
+     * ```typescript
+     * task.toggleMute().then(()=>{}).catch(()=>{})
+     * ```
+     */
+    toggleMute(options?: TaskToggleMuteOptions): Promise<void>;
+}

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

@@ -0,0 +1,55 @@
+import AnswerCallOnWebexService from '../../AnswerCallOnWebexService';
+import { TaskData, TaskToggleMuteOptions, TaskTransmitDtmfOptions } from '../types';
+import { TaskState } from '../state-machine';
+import MetricsManager from '../../../metrics/MetricsManager';
+import { WebexCallingDeviceDetails } from '../WebexCallingUtils';
+export type WxAppVoiceDependencies = {
+    enableWxBetterTogether: boolean;
+    answerCallOnWebexService?: AnswerCallOnWebexService;
+    agentId?: string;
+    metricsManager: MetricsManager;
+    getTaskData: () => TaskData;
+    getTaskState: () => TaskState | undefined;
+    getWxAppMuted: () => boolean;
+    setWxAppMuted: (muted: boolean) => void;
+};
+/** @deprecated Use {@link WxAppVoiceDependencies} */
+export type WxAppVoiceDeps = WxAppVoiceDependencies;
+export type WxAppVoiceLifecycle = {
+    setWxAppAcceptInFlight: (inFlight: boolean) => void;
+    setWxAppAnswerPending: (pending: boolean) => void;
+    resetWxAppMuted: () => void;
+    syncWxAppMuteFromCallDetails: () => Promise<boolean | undefined>;
+    mapWxAppVoiceError: (error: unknown, method: string) => never;
+};
+export declare function getCallingDeviceDetails(deps: WxAppVoiceDependencies): WebexCallingDeviceDetails | undefined;
+export declare function isWebexAppCallingOffer(deps: WxAppVoiceDependencies): boolean;
+/** Inbound wxApp offer only — outdial decline uses CC routing, not telephony reject. */
+export declare function isWebexAppInboundCallingOffer(deps: WxAppVoiceDependencies): boolean;
+export declare function getWebexCallingCallId(deps: WxAppVoiceDependencies): string | null;
+export declare function getWxAppLineOwnerId(deps: WxAppVoiceDependencies): string | undefined;
+export declare function resolveWxAppLineOwnerId(deps: WxAppVoiceDependencies, override?: string): string | undefined;
+export declare function acceptOnWebex(deps: WxAppVoiceDependencies, options?: {
+    lineOwnerId?: string;
+}): Promise<void>;
+export declare function rejectOnWebex(deps: WxAppVoiceDependencies, options?: {
+    lineOwnerId?: string;
+}): Promise<void>;
+export declare function toggleMuteOnWebex(deps: WxAppVoiceDependencies, options?: {
+    lineOwnerId?: string;
+    muted?: boolean;
+}): Promise<void>;
+export declare function transmitDtmfOnWebex(deps: WxAppVoiceDependencies, options: {
+    dtmf: string;
+    lineOwnerId?: string;
+}): Promise<void>;
+export declare function runWxAppAccept(deps: WxAppVoiceDependencies, lifecycle: WxAppVoiceLifecycle, options?: {
+    lineOwnerId?: string;
+}): Promise<void>;
+export declare function runWxAppReject(deps: WxAppVoiceDependencies, lifecycle: WxAppVoiceLifecycle, options?: {
+    lineOwnerId?: string;
+}): Promise<void>;
+export declare function runWxAppOutdialDecline<T>(deps: WxAppVoiceDependencies, executeCancel: () => Promise<T>): Promise<T>;
+export declare function runWxAppToggleMute(deps: WxAppVoiceDependencies, lifecycle: WxAppVoiceLifecycle, options?: TaskToggleMuteOptions): Promise<void>;
+export declare function runWxAppTransmitDtmf(deps: WxAppVoiceDependencies, lifecycle: WxAppVoiceLifecycle, options: TaskTransmitDtmfOptions): Promise<void>;
+export declare function mapWxAppVoiceError(error: unknown, method: string, module: string): never;

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

@@ -0,0 +1,51 @@
+export declare const WXAPP_LOG_FEATURE = "wxApp";
+export declare const WXAPP_LOG_PREFIX = "[CC wxApp]";
+export type WxAppAcceptReason = 'wxApp_offer_ready' | 'wxApp_answer_pending' | 'wxApp_accept_in_flight' | 'extension_non_wxApp_offer' | 'browser_webrtc_offer' | 'outdial_auto_answer';
+export type WxAppSessionSkipReason = 'unsupported_browser_login' | 'flag_disabled' | 'mercury_subscribe_failed' | 'publish_failed';
+export type WxAppTelephonyAction = 'accept' | 'decline' | 'mute' | 'dtmf';
+export type WxAppTelephonyPhase = 'started' | 'success' | 'failed';
+/** Last 8 chars of callId for correlation without logging full id. */
+export declare function callIdSuffix(callId: string | null | undefined): string | undefined;
+export declare function logWxAppSessionReadiness(params: {
+    enableWxBetterTogether: boolean;
+    loginOption: string | undefined;
+    wxAppHooksApplied: boolean;
+    usersubPublished: boolean;
+    mercurySubscribed: boolean;
+    telephonyTaskType: 'Voice' | 'WebRTC' | 'unknown';
+    skipReason?: WxAppSessionSkipReason;
+}): void;
+export declare function deriveWxAppAcceptReason(params: {
+    isWxAppInboundOffer: boolean;
+    isWxAppOutdialOffer: boolean;
+    isWebrtc: boolean;
+    isOutdial: boolean;
+    wxAppAcceptInFlight: boolean;
+    wxAppAnswerPending: boolean;
+    enableWxBetterTogether: boolean;
+    hasDeviceCallId: boolean;
+}): WxAppAcceptReason;
+export declare function logWxAppOfferDecision(params: {
+    interactionId: string;
+    acceptVisible: boolean;
+    acceptEnabled: boolean;
+    acceptReason: WxAppAcceptReason;
+    wxAppParticipantDeviceType?: string;
+    hasDeviceCallId: boolean;
+}): void;
+export declare function logWxAppTelephonyAction(params: {
+    action: WxAppTelephonyAction;
+    phase: WxAppTelephonyPhase;
+    interactionId?: string;
+    trackingId?: string;
+    httpStatus?: number | string;
+    failureReason?: string;
+}): void;
+export declare function logWxAppValidationFailure(reason: string, interactionId?: string): void;
+export declare function logWxAppMercuryMuteSync(params: {
+    phase: 'received' | 'applied' | 'dropped';
+    muted?: boolean;
+    callIdSuffix?: string;
+    interactionId?: string;
+    dropReason?: string;
+}): void;

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

@@ -0,0 +1,5 @@
+/**
+ * Expected Hydra responses when mute backfill races call creation (WXCC-6026).
+ * These must not be logged as errors — see task-spec wxApp mute backfill guard.
+ */
+export declare function isWxAppCallNotFoundError(error: unknown): boolean;

package/dist/types/types.d.ts

@@ -1,6 +1,6 @@
 import { CallingClientConfig } from '@webex/calling';
 import * as Agent from './services/agent/types';
-import { Profile } from './services/config/types';
+import { Entity, Profile } from './services/config/types';
 import { PaginatedResponse, BaseSearchParams } from './utils/PageCache';
 /**
  * HTTP methods supported by WebexRequest.
@@ -106,6 +106,10 @@ export interface CCPluginConfig {
     };
     /** Configuration for the calling client */
     callingClientConfig: CallingClientConfig;
+    /** Whether to skip Mobius/WebRTC registration for browser login flows */
+    disableWebRTCRegistration?: boolean;
+    /** Whether wxApp Better Together (telephony REST + usersub) is enabled at init (WXCC-6026) */
+    enableWxBetterTogether?: boolean;
 }
 /**
  * Logger interface for standardized logging throughout the plugin.
@@ -249,6 +253,8 @@ export interface IContactCenter {
      * cc.register().then(profile => { ... });
      */
     register(): Promise<Profile>;
+    /** Returns the system-managed WellbeingBreak idle code for the registered session. */
+    getWellbeingBreakIdleCode(): Promise<Entity>;
 }
 /**
  * Generic HTTP response structure.
@@ -364,26 +370,29 @@ export type AgentLogin = {
 export type AgentProfileUpdate = Pick<AgentLogin, 'loginOption' | 'dialNumber' | 'teamId'>;
 /**
  * Represents the options to fetch buddy agents for the logged in agent.
- * Buddy agents are other agents who can be consulted or transfered to.
+ * Buddy agents are other agents who can be consulted or transferred to.
  * @public
  * @example
  * const opts: BuddyAgents = { mediaType: 'telephony', state: 'Available' };
- * @ignore
  */
 export type BuddyAgents = {
     /**
-     * The media type channel to filter buddy agents.
-     * Determines which channel capability the returned agents must have.
+     * The media type channel to filter buddy agents. Defaults to telephony when omitted.
      */
-    mediaType: 'telephony' | 'chat' | 'social' | 'email';
+    mediaType?: 'telephony' | 'chat' | 'social' | 'email';
     /**
      * Optional filter for agent state.
      * If specified, returns only agents in that state.
      * If omitted, returns both available and idle agents.
      */
     state?: 'Available' | 'Idle';
+    /**
+     * Applies the default state policy for the operation. An explicit state takes precedence.
+     */
+    action?: 'Consult' | 'Transfer';
 };
 /**
+
  * Generic error structure for Contact Center SDK errors.
  * Contains detailed information about the error context.
  * @public
@@ -461,10 +470,12 @@ export interface AddressBookEntrySearchParams extends BaseSearchParams {
 export interface EntryPointRecord {
     id: string;
     name: string;
+    /** Dialled number mapped to this entry point when included in the list response. */
+    number?: string;
     description?: string;
-    type: string;
-    isActive: boolean;
-    orgId: string;
+    type?: string;
+    isActive?: boolean;
+    orgId?: string;
     createdAt?: string;
     updatedAt?: string;
     settings?: Record<string, any>;
@@ -612,32 +623,217 @@ export type BuddyAgentsResponse = Agent.BuddyAgentsSuccess | Error;
  * function handleUpdateDeviceType(resp: UpdateDeviceTypeResponse) { ... }
  */
 export type UpdateDeviceTypeResponse = Agent.DeviceTypeUpdateSuccess | Error;
+/**
+ * Supported transcript control actions for AI Assistant events.
+ * @public
+ * @example
+ * const action: TranscriptAction = 'START';
+ * @ignore
+ */
 export type TranscriptAction = 'START' | 'STOP';
+/**
+ * Parameters used to request AI Assistant real-time assistance.
+ * @public
+ * @example
+ * const params: RealTimeAssistanceParams = {
+ *   interactionId: 'interaction-123',
+ *   context: 'Need help with credit card payment due date',
+ * };
+ */
+export type RealTimeAssistanceParams = {
+    /** Agent identifier */
+    agentId: string;
+    /** Interaction identifier for which assistance should be generated */
+    interactionId: string;
+    /** Optional additional context that should refine the assistance */
+    context?: string;
+    /** Optional language code for assistance (for example, 'en'). Defaults to 'en'. */
+    languageCode?: string;
+};
+/**
+ * Supported user actions on an AI Assistant real-time assistance adaptive card.
+ * @public
+ */
+export declare const RealTimeAssistanceUserActionId: {
+    /** User liked the real-time assistance response */
+    readonly LIKE: "likeButton";
+    /** User disliked the real-time assistance response */
+    readonly DISLIKE: "dislikeButton";
+    /** User copied the real-time assistance response */
+    readonly COPY: "copyButton";
+};
+/**
+ * Union type of supported real-time assistance user actions.
+ * @public
+ */
+export type RealTimeAssistanceUserActionId = Enum<typeof RealTimeAssistanceUserActionId>;
+/**
+ * Parameters used to send user action feedback for a real-time assistance adaptive card.
+ * @public
+ * @example
+ * const params: RealTimeAssistanceUserActionParams = {
+ *   agentId: 'agent-123',
+ *   interactionId: 'interaction-123',
+ *   adaptiveCardId: 'adaptive-card-123',
+ *   actionId: RealTimeAssistanceUserActionId.LIKE,
+ * };
+ */
+export type RealTimeAssistanceUserActionParams = {
+    /** Agent identifier */
+    agentId: string;
+    /** Interaction identifier associated with the real-time assistance response */
+    interactionId: string;
+    /** Adaptive card identifier from the real-time assistance payload */
+    adaptiveCardId: string;
+    /** User action performed on the adaptive card */
+    actionId: RealTimeAssistanceUserActionId;
+    /** Optional language code. Defaults to 'en'. */
+    languageCode?: string;
+};
+/**
+ * Wellness notification actions delivered by the Contact Center notification service.
+ * @public
+ */
+export declare const WELLNESS_BREAK_NOTIFICATION_ACTIONS: {
+    readonly PROVIDE_WELLNESS_BREAK: "PROVIDE_WELLNESS_BREAK";
+    readonly SUGGEST_WELLNESS_BREAK: "SUGGEST_WELLNESS_BREAK";
+    readonly WELLNESS_BREAK_NOT_ALLOWED: "WELLNESS_BREAK_NOT_ALLOWED";
+};
+/** Union of supported wellness notification actions. @public */
+export type WellnessBreakNotificationAction = Enum<typeof WELLNESS_BREAK_NOTIFICATION_ACTIONS>;
+/**
+ * Agent actions accepted by the wellness action API.
+ * @public
+ */
+export declare const WELLNESS_BREAK_USER_ACTIONS: {
+    readonly REQUESTED: "REQUESTED";
+    readonly ACCEPTED: "ACCEPTED";
+    readonly REJECTED: "REJECTED";
+    readonly NO_RESPONSE: "NO_RESPONSE";
+};
+/** Union of supported wellness action API values. @public */
+export type WellnessBreakUserAction = Enum<typeof WELLNESS_BREAK_USER_ACTIONS>;
+/**
+ * Validated, agent-scoped wellness notification emitted by Contact Center.
+ * @public
+ */
+export interface WellnessBreakEvent {
+    /** Agent identifier */
+    agentId: string;
+    /** Organization identifier */
+    orgId: string;
+    /** Session identifier supplied by the notification; it may differ from the consumer's active session */
+    agentSessionId: string;
+    /** Backend wellness action */
+    actionEvent: WellnessBreakNotificationAction;
+    /** Optional untrusted plain-text message supplied by the backend */
+    actionText?: string;
+    /** Optional normalized interaction diagnostic */
+    interactionId?: string;
+    /** Notification diagnostic only; never an action-request correlation identifier */
+    trackingId?: string;
+}
+/**
+ * Parameters for responding to a backend-provided wellness offer.
+ * @public
+ */
+export interface RespondToWellnessBreakParams {
+    /** Agent response; REQUESTED is available only through requestWellnessBreak */
+    action: Exclude<WellnessBreakUserAction, typeof WELLNESS_BREAK_USER_ACTIONS.REQUESTED>;
+}
+/**
+ * Supported AI Assistant event categories.
+ * @public
+ * @example
+ * const eventType: AIAssistantEventType = AIAssistantEventType.CUSTOM_EVENT;
+ * @ignore
+ */
 export declare const AIAssistantEventType: {
+    /** Custom AI Assistant event */
     readonly CUSTOM_EVENT: "CUSTOM_EVENT";
+    /** CTI-backed AI Assistant event */
     readonly CTI_EVENT: "CTI_EVENT";
 };
+/**
+ * Union type of AI Assistant event categories.
+ * @public
+ * @example
+ * function send(type: AIAssistantEventType) { ... }
+ * @ignore
+ */
 export type AIAssistantEventType = Enum<typeof AIAssistantEventType>;
+/**
+ * Supported AI Assistant event names.
+ * @public
+ * @example
+ * const name: AIAssistantEventName = AIAssistantEventName.GET_TRANSCRIPTS;
+ * @ignore
+ */
 export declare const AIAssistantEventName: {
+    /** Request transcript streaming for an interaction */
     readonly GET_TRANSCRIPTS: "GET_TRANSCRIPTS";
+    /** Request a suggested response for an interaction */
+    readonly GET_SUGGESTIONS: "GET_SUGGESTIONS";
+    /** Add extra context to refine a suggested response */
+    readonly ADD_SUGGESTIONS_EXTRA_CONTEXT: "ADD_SUGGESTIONS_EXTRA_CONTEXT";
+    /** Request mid-call summary generation */
     readonly GET_MID_CALL_SUMMARY: "GET_MID_CALL_SUMMARY";
+    /** Request post-call summary generation */
     readonly GET_POST_CALL_SUMMARY: "GET_POST_CALL_SUMMARY";
+    /** Mid-call summary response event */
     readonly MID_CALL_SUMMARY_RESPONSE: "MID_CALL_SUMMARY_RESPONSE";
+    /** Post-call summary response event */
     readonly POST_CALL_SUMMARY_RESPONSE: "POST_CALL_SUMMARY_RESPONSE";
+    /** Suggested digital response event */
     readonly SUGGESTED_RESPONSES_DIGITAL: "SUGGESTED_RESPONSES_DIGITAL";
+    /** User action on a suggested response adaptive card */
+    readonly SUGGESTED_RESPONSES_USER_ACTION: "SUGGESTED_RESPONSES_USER_ACTION";
+    /** Agent Wellness Break request/response action */
+    readonly WELLNESS_BREAK_ACTION: "WellnessBreakAction";
 };
+/**
+ * Union type of AI Assistant event names.
+ * @public
+ * @example
+ * function handle(name: AIAssistantEventName) { ... }
+ * @ignore
+ */
 export type AIAssistantEventName = Enum<typeof AIAssistantEventName>;
+/**
+ * A single transcript message entry returned by AI Assistant APIs.
+ * @public
+ * @example
+ * const message: TranscriptMessage = { role: 'AGENT', content: 'Hello', messageId: '1', publishTimestamp: Date.now() };
+ *
+ */
 export type TranscriptMessage = {
+    /** Speaker role for this message */
     role: string;
+    /** Transcript chunk content */
     content: string;
+    /** Unique message identifier */
     messageId: string;
+    /** Message publish timestamp (epoch milliseconds) */
     publishTimestamp: number;
 };
+/**
+ * Response payload for historic transcripts API.
+ * @public
+ * @example
+ * const resp: HistoricTranscriptsResponse = { orgId: 'org', agentId: 'agent', conversationId: null, interactionId: 'int', source: 'AI', data: [] };
+ *
+ */
 export type HistoricTranscriptsResponse = {
+    /** Organization identifier */
     orgId: string;
+    /** Agent identifier */
     agentId: string;
+    /** Conversation identifier when available */
     conversationId: string | null;
+    /** Interaction identifier */
     interactionId: string;
+    /** Data source identifier */
     source: string;
+    /** Transcript messages */
     data: TranscriptMessage[];
 };