@webex/contact-center 3.11.0 → 3.12.0-auth-prejoin-fetch.1

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

@@ -0,0 +1,223 @@
+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 wxAppMuteToggleInFlight?;
+    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;
+    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,52 @@
+import AnswerCallOnWebexService from '../../AnswerCallOnWebexService';
+import { TaskData, TaskToggleMuteOptions, TaskTransmitDtmfOptions } from '../types';
+import { TaskState } from '../state-machine';
+import { WebexCallingDeviceDetails } from '../WebexCallingUtils';
+export type WxAppVoiceDependencies = {
+    enableWxBetterTogether: boolean;
+    answerCallOnWebexService?: AnswerCallOnWebexService;
+    agentId?: string;
+    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 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/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;