/// <reference types="node" />
import { CallId } from '@webex/calling/dist/types/common/types';
import EventEmitter from 'events';
import { Msg } from '../core/GlobalTypes';
import AutoWrapup from './AutoWrapup';
/**
 * Unique identifier for a task in the contact center system
 * @public
 */
export type TaskId = string;
/**
 * Defines the valid destination types for routing tasks within the contact center
 * Used to specify where a task should be directed
 * @public
 */
export declare const DESTINATION_TYPE: {
    /** Route task to a specific queue */
    QUEUE: string;
    /** Route task to a specific dial number */
    DIALNUMBER: string;
    /** Route task to a specific agent */
    AGENT: string;
    /** Route task to an entry point (supported only for consult operations) */
    ENTRYPOINT: string;
};
/**
 * Type representing valid destination types for task routing
 * Derived from the DESTINATION_TYPE constant
 * @public
 */
export type DestinationType = Enum<typeof DESTINATION_TYPE>;
/**
 * Defines the valid destination types for consult transfer operations
 * Used when transferring a task after consultation
 * @public
 */
export declare const CONSULT_TRANSFER_DESTINATION_TYPE: {
    /** Transfer to a specific agent */
    AGENT: string;
    /** Transfer to an entry point */
    ENTRYPOINT: string;
    /** Transfer to a dial number */
    DIALNUMBER: string;
    /** Transfer to a queue */
    QUEUE: string;
};
/**
 * Type representing valid destination types for consult transfers
 * Derived from the CONSULT_TRANSFER_DESTINATION_TYPE constant
 * @public
 */
export type ConsultTransferDestinationType = Enum<typeof CONSULT_TRANSFER_DESTINATION_TYPE>;
/**
 * Defines all supported media channel types for customer interactions
 * These represent the different ways customers can communicate with agents
 * @public
 */
export declare const MEDIA_CHANNEL: {
    /** Email-based communication channel */
    readonly EMAIL: "email";
    /** Web-based chat communication channel */
    readonly CHAT: "chat";
    /** Voice/phone communication channel */
    readonly TELEPHONY: "telephony";
    /** Social media platform communication channel */
    readonly SOCIAL: "social";
    /** SMS text messaging communication channel */
    readonly SMS: "sms";
    /** Facebook Messenger communication channel */
    readonly FACEBOOK: "facebook";
    /** WhatsApp messaging communication channel */
    readonly WHATSAPP: "whatsapp";
};
/**
 * Type representing valid media channels
 * Derived from the MEDIA_CHANNEL constant
 * @public
 */
export type MEDIA_CHANNEL = Enum<typeof MEDIA_CHANNEL>;
/**
 * Enumeration of all task-related events that can occur in the contact center system
 * These events represent different states and actions in the task lifecycle
 * @public
 */
export declare enum TASK_EVENTS {
    /**
     * Triggered when a new task is received by the system
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_INCOMING, (task: ITask) => {
     *   console.log('New task received:', task.data.interactionId);
     *   // Handle incoming task
     * });
     * ```
     */
    TASK_INCOMING = "task:incoming",
    /**
     * Triggered when a task is successfully assigned to an agent
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_ASSIGNED, (task: ITask) => {
     *   console.log('Task assigned:', task.data.interactionId);
     *   // Begin handling the assigned task
     * });
     * ```
     */
    TASK_ASSIGNED = "task:assigned",
    /**
     * Triggered when the media state of a task changes
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_MEDIA, (track: MediaStreamTrack) => {
     *   // Handle media track updates
     * });
     * ```
     */
    TASK_MEDIA = "task:media",
    /**
     * Triggered when a task is removed from an agent
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_UNASSIGNED, (task: ITask) => {
     *   console.log('Task unassigned:', task.data.interactionId);
     *   // Clean up task resources
     * });
     * ```
     */
    TASK_UNASSIGNED = "task:unassigned",
    /**
     * Triggered when a task is placed on hold
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_HOLD, (task: ITask) => {
     *   console.log('Task placed on hold:', task.data.interactionId);
     *   // Update UI to show hold state
     * });
     * ```
     */
    TASK_HOLD = "task:hold",
    /**
     * Triggered when a task is resumed from hold
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_RESUME, (task: ITask) => {
     *   console.log('Task resumed from hold:', task.data.interactionId);
     *   // Update UI to show active state
     * });
     * ```
     */
    TASK_RESUME = "task:resume",
    /**
     * Triggered when a consultation session ends
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_CONSULT_END, (task: ITask) => {
     *   console.log('Consultation ended:', task.data.interactionId);
     *   // Clean up consultation resources
     * });
     * ```
     */
    TASK_CONSULT_END = "task:consultEnd",
    /**
     * Triggered when a queue consultation is cancelled
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_CONSULT_QUEUE_CANCELLED, (task: ITask) => {
     *   console.log('Queue consultation cancelled:', task.data.interactionId);
     *   // Handle consultation cancellation
     * });
     * ```
     */
    TASK_CONSULT_QUEUE_CANCELLED = "task:consultQueueCancelled",
    /**
     * Triggered when a queue consultation fails
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_CONSULT_QUEUE_FAILED, (task: ITask) => {
     *   console.log('Queue consultation failed:', task.data.interactionId);
     *   // Handle consultation failure
     * });
     * ```
     */
    TASK_CONSULT_QUEUE_FAILED = "task:consultQueueFailed",
    /**
     * Triggered when a consultation request is accepted
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_CONSULT_ACCEPTED, (task: ITask) => {
     *   console.log('Consultation accepted:', task.data.interactionId);
     *   // Begin consultation
     * });
     * ```
     */
    TASK_CONSULT_ACCEPTED = "task:consultAccepted",
    /**
     * Triggered when consultation is in progress
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_CONSULTING, (task: ITask) => {
     *   console.log('Consulting in progress:', task.data.interactionId);
     *   // Handle ongoing consultation
     * });
     * ```
     */
    TASK_CONSULTING = "task:consulting",
    /**
     * Triggered when a new consultation is created
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_CONSULT_CREATED, (task: ITask) => {
     *   console.log('Consultation created:', task.data.interactionId);
     *   // Initialize consultation
     * });
     * ```
     */
    TASK_CONSULT_CREATED = "task:consultCreated",
    /**
     * Triggered when a consultation is offered
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_OFFER_CONSULT, (task: ITask) => {
     *   console.log('Consultation offered:', task.data.interactionId);
     *   // Handle consultation offer
     * });
     * ```
     */
    TASK_OFFER_CONSULT = "task:offerConsult",
    /**
     * Triggered when a task is completed/terminated
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_END, (task: ITask) => {
     *   console.log('Task ended:', task.data.interactionId);
     *   // Clean up and finalize task
     * });
     * ```
     */
    TASK_END = "task:end",
    /**
     * Triggered when a task enters wrap-up state
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_WRAPUP, (task: ITask) => {
     *   console.log('Task in wrap-up:', task.data.interactionId);
     *   // Begin wrap-up process
     * });
     * ```
     */
    TASK_WRAPUP = "task:wrapup",
    /**
     * Triggered when task wrap-up is completed
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_WRAPPEDUP, (task: ITask) => {
     *   console.log('Task wrapped up:', task.data.interactionId);
     *   // Finalize task completion
     * });
     * ```
     */
    TASK_WRAPPEDUP = "task:wrappedup",
    /**
     * Triggered when recording is paused
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_RECORDING_PAUSED, (task: ITask) => {
     *   console.log('Recording paused:', task.data.interactionId);
     *   // Update recording state
     * });
     * ```
     */
    TASK_RECORDING_PAUSED = "task:recordingPaused",
    /**
     * Triggered when recording pause attempt fails
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_RECORDING_PAUSE_FAILED, (task: ITask) => {
     *   console.log('Recording pause failed:', task.data.interactionId);
     *   // Handle pause failure
     * });
     * ```
     */
    TASK_RECORDING_PAUSE_FAILED = "task:recordingPauseFailed",
    /**
     * Triggered when recording is resumed
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_RECORDING_RESUMED, (task: ITask) => {
     *   console.log('Recording resumed:', task.data.interactionId);
     *   // Update recording state
     * });
     * ```
     */
    TASK_RECORDING_RESUMED = "task:recordingResumed",
    /**
     * Triggered when recording resume attempt fails
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, (task: ITask) => {
     *   console.log('Recording resume failed:', task.data.interactionId);
     *   // Handle resume failure
     * });
     * ```
     */
    TASK_RECORDING_RESUME_FAILED = "task:recordingResumeFailed",
    /**
     * Triggered when a task is rejected/unanswered
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_REJECT, (task: ITask) => {
     *   console.log('Task rejected:', task.data.interactionId);
     *   // Handle task rejection
     * });
     * ```
     */
    TASK_REJECT = "task:rejected",
    /**
     * Triggered when an outdial call fails
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_OUTDIAL_FAILED, (reason: string) => {
     *   console.log('Outdial failed:', reason);
     *   // Handle outdial failure
     * });
     * ```
     */
    TASK_OUTDIAL_FAILED = "task:outdialFailed",
    /**
     * Triggered when a task is populated with data
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_HYDRATE, (task: ITask) => {
     *   console.log('Task hydrated:', task.data.interactionId);
     *   // Process task data
     * });
     * ```
     */
    TASK_HYDRATE = "task:hydrate",
    /**
     * Triggered when a new contact is offered
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_OFFER_CONTACT, (task: ITask) => {
     *   console.log('Contact offered:', task.data.interactionId);
     *   // Handle contact offer
     * });
     * ```
     */
    TASK_OFFER_CONTACT = "task:offerContact",
    /**
     * Triggered when a task has been successfully auto-answered
     * This event is emitted after the SDK automatically accepts a task due to:
     * - WebRTC calls with auto-answer enabled
     * - Agent-initiated outdial calls
     * - Other auto-answer scenarios
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_AUTO_ANSWERED, (task: ITask) => {
     *   console.log('Task auto-answered:', task.data.interactionId);
     *   // Update UI - enable cancel button, etc.
     * });
     * ```
     */
    TASK_AUTO_ANSWERED = "task:autoAnswered",
    /**
     * 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",
    /**
     * Triggered when a campaign preview contact is offered to the agent
     * @example
     * ```typescript
     * task.on(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, (data: AgentContact) => {
     *   console.log('Campaign preview contact received:', data.interactionId);
     *   // Handle campaign preview reservation
     * });
     * ```
     */
    TASK_CAMPAIGN_PREVIEW_RESERVATION = "task:campaignPreviewReservation"
}
/**
 * Represents a customer interaction within the contact center system
 * Contains comprehensive details about an ongoing customer interaction
 * @public
 */
export type Interaction = {
    /** Indicates if the interaction is managed by Flow Control */
    isFcManaged: boolean;
    /** Indicates if the interaction has been terminated */
    isTerminated: boolean;
    /** The type of media channel for this interaction */
    mediaType: MEDIA_CHANNEL;
    /** List of previous virtual teams that handled this interaction */
    previousVTeams: string[];
    /** Current state of the interaction */
    state: string;
    /** Current virtual team handling the interaction */
    currentVTeam: string;
    /** List of participants in the interaction */
    participants: any;
    /** Unique identifier for the interaction */
    interactionId: string;
    /** Organization identifier */
    orgId: string;
    /** Timestamp when the interaction was created */
    createdTimestamp?: number;
    /** Indicates if wrap-up assistance is enabled */
    isWrapUpAssist?: boolean;
    /** Detailed call processing information and metadata */
    callProcessingDetails: {
        /** Name of the Queue Manager handling this interaction */
        QMgrName: string;
        /** Indicates if the task should be self-serviced */
        taskToBeSelfServiced: string;
        /** Automatic Number Identification (caller's number) */
        ani: string;
        /** Display version of the ANI */
        displayAni: string;
        /** Dialed Number Identification Service number */
        dnis: string;
        /** Tenant identifier */
        tenantId: string;
        /** Queue identifier */
        QueueId: string;
        /** Virtual team identifier */
        vteamId: string;
        /** Indicates if pause/resume functionality is enabled */
        pauseResumeEnabled?: string;
        /** Duration of pause in seconds */
        pauseDuration?: string;
        /** Indicates if the interaction is currently paused */
        isPaused?: string;
        /** Indicates if recording is in progress */
        recordInProgress?: string;
        /** Indicates if recording has started */
        recordingStarted?: string;
        /** Indicates if Consult to Queue is in progress */
        ctqInProgress?: string;
        /** Indicates if outdial transfer to queue is enabled */
        outdialTransferToQueueEnabled?: string;
        /** IVR conversation transcript */
        convIvrTranscript?: string;
        /** Customer's name */
        customerName: string;
        /** Name of the virtual team */
        virtualTeamName: string;
        /** RONA (Redirection on No Answer) timeout in seconds */
        ronaTimeout: string;
        /** Category of the interaction */
        category: string;
        /** Reason for the interaction */
        reason: string;
        /** Source number for the interaction */
        sourceNumber: string;
        /** Source page that initiated the interaction */
        sourcePage: string;
        /** Application user identifier */
        appUser: string;
        /** Customer's contact number */
        customerNumber: string;
        /** Code indicating the reason for interaction */
        reasonCode: string;
        /** Path taken through the IVR system */
        IvrPath: string;
        /** Identifier for the IVR path */
        pathId: string;
        /** Email address or contact point that initiated the interaction */
        fromAddress: string;
        /** Identifier of the parent interaction for related interactions */
        parentInteractionId?: string;
        /** Identifier of the child interaction for related interactions */
        childInteractionId?: string;
        /** Type of relationship between parent and child interactions */
        relationshipType?: string;
        /** ANI of the parent interaction */
        parent_ANI?: string;
        /** DNIS of the parent interaction */
        parent_DNIS?: string;
        /** Indicates if the consulted destination agent has joined */
        consultDestinationAgentJoined?: boolean | string;
        /** Name of the destination agent for consultation */
        consultDestinationAgentName?: string;
        /** DN of the parent interaction's agent */
        parent_Agent_DN?: string;
        /** Name of the parent interaction's agent */
        parent_Agent_Name?: string;
        /** Team name of the parent interaction's agent */
        parent_Agent_TeamName?: string;
        /** Indicates if the interaction is in conference mode */
        isConferencing?: string;
        /** Type of monitoring being performed */
        monitorType?: string;
        /** Name of the workflow being executed */
        workflowName?: string;
        /** Identifier of the workflow */
        workflowId?: string;
        /** Indicates if monitoring is in invisible mode */
        monitoringInvisibleMode?: string;
        /** Identifier for the monitoring request */
        monitoringRequestId?: string;
        /** Timeout for participant invitation */
        participantInviteTimeout?: string;
        /** Filename for music on hold */
        mohFileName?: string;
        /** Flag for continuing recording during transfer */
        CONTINUE_RECORDING_ON_TRANSFER?: string;
        /** Entry point identifier */
        EP_ID?: string;
        /** Type of routing being used */
        ROUTING_TYPE?: string;
        /** Events registered with Flow Control Engine */
        fceRegisteredEvents?: string;
        /** Indicates if the interaction is parked */
        isParked?: string;
        /** Priority level of the interaction */
        priority?: string;
        /** Identifier for the routing strategy */
        routingStrategyId?: string;
        /** Current state of monitoring */
        monitoringState?: string;
        /** Indicates if blind transfer is in progress */
        BLIND_TRANSFER_IN_PROGRESS?: boolean;
        /** Desktop view configuration for Flow Control */
        fcDesktopView?: string;
        /** Agent ID who initiated the outdial call */
        outdialAgentId?: string;
    };
    /** Main interaction identifier for related interactions */
    mainInteractionId?: string;
    /** Media-specific information for the interaction */
    media: Record<string, {
        /** Unique identifier for the media resource */
        mediaResourceId: string;
        /** Type of media channel */
        mediaType: MEDIA_CHANNEL;
        /** Media manager handling this media */
        mediaMgr: string;
        /** List of participant identifiers */
        participants: string[];
        /** Type of media */
        mType: string;
        /** Indicates if media is on hold */
        isHold: boolean;
        /** Timestamp when media was put on hold */
        holdTimestamp: number | null;
    }>;
    /** Owner of the interaction */
    owner: string;
    /** Primary media channel for the interaction */
    mediaChannel: MEDIA_CHANNEL;
    /** Direction information for the contact */
    contactDirection: {
        type: string;
    };
    /** Type of outbound interaction */
    outboundType?: string;
    /** Parameters passed through the call flow */
    callFlowParams: Record<string, {
        /** Name of the parameter */
        name: string;
        /** Qualifier for the parameter */
        qualifier: string;
        /** Description of the parameter */
        description: string;
        /** Data type of the parameter value */
        valueDataType: string;
        /** Value of the parameter */
        value: string;
    }>;
};
/**
 * Task payload containing detailed information about a contact center task
 * This structure encapsulates all relevant data for task management
 * @public
 */
export type TaskData = {
    /** Unique identifier for the media resource handling this task */
    mediaResourceId: string;
    /** Type of event that triggered this task data */
    eventType: string;
    /** Timestamp when the event occurred */
    eventTime?: number;
    /** Identifier of the agent handling the task */
    agentId: string;
    /** Identifier of the destination agent for transfers/consults */
    destAgentId: string;
    /** Unique tracking identifier for the task */
    trackingId: string;
    /** Media resource identifier for consultation operations */
    consultMediaResourceId: string;
    /** Detailed interaction information */
    interaction: Interaction;
    /** Unique identifier for the participant */
    participantId?: string;
    /** Indicates if the task is from the owner */
    fromOwner?: boolean;
    /** Indicates if the task is to the owner */
    toOwner?: boolean;
    /** Identifier for child interaction in consult/transfer scenarios */
    childInteractionId?: string;
    /** Unique identifier for the interaction */
    interactionId: string;
    /** Organization identifier */
    orgId: string;
    /** Current owner of the task */
    owner: string;
    /** Queue manager handling the task */
    queueMgr: string;
    /** Name of the queue where task is queued */
    queueName?: string;
    /** Type of the task */
    type: string;
    /** Timeout value for RONA (Redirection on No Answer) in seconds */
    ronaTimeout?: number;
    /** Indicates if the task is in consultation state */
    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 */
    destinationType?: string;
    /** Indicates if the task was automatically resumed */
    autoResumed?: boolean;
    /** Code indicating the reason for an action */
    reasonCode?: string | number;
    /** Description of the reason for an action */
    reason?: string;
    /** Identifier of the consulting agent */
    consultingAgentId?: string;
    /** Unique identifier for the task */
    taskId?: string;
    /** Task details including state and media information */
    task?: Interaction;
    /** Unique identifier for monitoring offered events */
    id?: string;
    /** Indicates if the web call is muted */
    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;
    /** Indicates if auto-answer is in progress for this task */
    isAutoAnswering?: boolean;
    /** Indicates if wrap-up is required for this task */
    agentsPendingWrapUp?: string[];
};
/**
 * Type representing an agent contact message within the contact center system
 * Contains comprehensive interaction and task related details for agent operations
 * @public
 */
export type AgentContact = Msg<{
    /** Unique identifier for the media resource */
    mediaResourceId: string;
    /** Type of the event (e.g., 'AgentDesktopMessage') */
    eventType: string;
    /** Timestamp when the event occurred */
    eventTime?: number;
    /** Unique identifier of the agent handling the contact */
    agentId: string;
    /** Identifier of the destination agent for transfers/consults */
    destAgentId: string;
    /** Unique tracking identifier for the contact */
    trackingId: string;
    /** Media resource identifier for consult operations */
    consultMediaResourceId: string;
    /** Detailed interaction information including media and participant data */
    interaction: Interaction;
    /** Unique identifier for the participant */
    participantId?: string;
    /** Indicates if the message is from the owner of the interaction */
    fromOwner?: boolean;
    /** Indicates if the message is to the owner of the interaction */
    toOwner?: boolean;
    /** Identifier for child interaction in case of consult/transfer */
    childInteractionId?: string;
    /** Unique identifier for the interaction */
    interactionId: string;
    /** Organization identifier */
    orgId: string;
    /** Current owner of the interaction */
    owner: string;
    /** Queue manager handling the interaction */
    queueMgr: string;
    /** Name of the queue where interaction is queued */
    queueName?: string;
    /** Type of the contact/interaction */
    type: string;
    /** Timeout value for RONA (Redirection on No Answer) in seconds */
    ronaTimeout?: number;
    /** Indicates if the interaction is in consult state */
    isConsulted?: boolean;
    /** Indicates if the interaction is in conference state */
    isConferencing: boolean;
    /** Identifier of the agent who last updated the interaction */
    updatedBy?: string;
    /** Type of destination for transfer/consult */
    destinationType?: string;
    /** Indicates if the interaction was automatically resumed */
    autoResumed?: boolean;
    /** Code indicating the reason for an action */
    reasonCode?: string | number;
    /** Description of the reason for an action */
    reason?: string;
    /** Identifier of the consulting agent */
    consultingAgentId?: string;
    /** Unique identifier for the task */
    taskId?: string;
    /** Task details including media and state information */
    task?: Interaction;
    /** Identifier of the supervisor monitoring the interaction */
    supervisorId?: string;
    /** Type of monitoring (e.g., 'SILENT', 'BARGE_IN') */
    monitorType?: string;
    /** Dial number of the supervisor */
    supervisorDN?: string;
    /** Unique identifier for monitoring offered events */
    id?: string;
    /** Indicates if the web call is muted */
    isWebCallMute?: boolean;
    /** Identifier for reservation interaction */
    reservationInteractionId?: string;
    /** Identifier for the reserved agent channel */
    reservedAgentChannelId?: string;
    /** Current monitoring state information */
    monitoringState?: {
        /** Type of monitoring state */
        type: string;
    };
    /** Name of the supervisor monitoring the interaction */
    supervisorName?: string;
}>;
/**
 * Information about a virtual team in the contact center
 * @ignore
 */
export type VTeam = {
    /** Profile ID of the agent in the virtual team */
    agentProfileId: string;
    /** Session ID of the agent in the virtual team */
    agentSessionId: string;
    /** Type of channel handled by the virtual team */
    channelType: string;
    /** Type of the virtual team */
    type: string;
    /** Optional tracking identifier */
    trackingId?: string;
};
/**
 * Detailed information about a virtual team configuration
 * @ignore
 */
export type VteamDetails = {
    /** Name of the virtual team */
    name: string;
    /** Type of channel handled by the virtual team */
    channelType: string;
    /** Unique identifier for the virtual team */
    id: string;
    /** Type of the virtual team */
    type: string;
    /** ID of the analyzer associated with the team */
    analyzerId: string;
};
/**
 * Response type for successful virtual team operations
 * Contains details about virtual teams and their capabilities
 * @ignore
 */
export type VTeamSuccess = Msg<{
    /** Response data containing team information */
    data: {
        /** List of virtual team details */
        vteamList: Array<VteamDetails>;
        /** Whether queue consultation is allowed */
        allowConsultToQueue: boolean;
    };
    /** Method name from JavaScript */
    jsMethod: string;
    /** Data related to the call */
    callData: string;
    /** Session ID of the agent */
    agentSessionId: string;
}>;
/**
 * Parameters for putting a task on hold or resuming from hold
 * @public
 */
export type HoldResumePayload = {
    /** Unique identifier for the media resource to hold/resume */
    mediaResourceId: string;
};
/**
 * Parameters for resuming a task's recording
 * @public
 */
export type ResumeRecordingPayload = {
    /** Indicates if the recording was automatically resumed */
    autoResumed: boolean;
};
/**
 * Parameters for transferring a task to another destination
 * @public
 */
export type TransferPayLoad = {
    /** Destination identifier where the task will be transferred to */
    to: string;
    /** Type of the destination (queue, agent, etc.) */
    destinationType: DestinationType;
};
/**
 * Parameters for initiating a consultative transfer
 * @public
 */
export type ConsultTransferPayLoad = {
    /** Destination identifier for the consultation transfer */
    to: string;
    /** Type of the consultation transfer destination */
    destinationType: ConsultTransferDestinationType;
};
/**
 * Parameters for initiating a consultation with another agent or queue
 * @public
 */
export type ConsultPayload = {
    /** Destination identifier for the consultation */
    to: string | undefined;
    /** Type of the consultation destination (agent, queue, etc.) */
    destinationType: DestinationType;
    /** Whether to hold other participants during consultation (always true) */
    holdParticipants?: boolean;
};
/**
 * Parameters for ending a consultation task
 * @public
 */
export type ConsultEndPayload = {
    /** Indicates if this is a consultation operation */
    isConsult: boolean;
    /** Indicates if this involves a secondary entry point or DN agent */
    isSecondaryEpDnAgent?: boolean;
    /** Optional queue identifier for the consultation */
    queueId?: string;
    /** Identifier of the task being consulted */
    taskId: string;
};
/**
 * Parameters for transferring a task to another destination
 * @public
 */
export type TransferPayload = {
    /** Destination identifier where the task will be transferred */
    to: string | undefined;
    /** Type of the transfer destination */
    destinationType: DestinationType;
};
/**
 * API payload for ending a consultation
 * This is the actual payload that is sent to the developer API
 * @public
 */
export type ConsultEndAPIPayload = {
    /** Optional identifier of the queue involved in the consultation */
    queueId?: string;
};
/**
 * Data required for consulting and conferencing operations
 * @public
 */
export type ConsultConferenceData = {
    /** Identifier of the agent initiating consult/conference */
    agentId?: string;
    /** Target destination for the consult/conference */
    to: string | undefined;
    /** Type of destination (e.g., 'agent', 'queue') */
    destinationType: string;
};
/**
 * Parameters required for cancelling a consult to queue operation
 * @public
 */
export type cancelCtq = {
    /** Identifier of the agent cancelling the CTQ */
    agentId: string;
    /** Identifier of the queue where consult was initiated */
    queueId: string;
};
/**
 * Parameters required for declining a task
 * @public
 */
export type declinePayload = {
    /** Identifier of the media resource to decline */
    mediaResourceId: string;
};
/**
 * Parameters for wrapping up a task with relevant completion details
 * @public
 */
export type WrapupPayLoad = {
    /** The reason provided for wrapping up the task */
    wrapUpReason: string;
    /** Auxiliary code identifier associated with the wrap-up state */
    auxCodeId: string;
};
/**
 * Configuration parameters for initiating outbound dialer tasks
 * @public
 */
export type DialerPayload = {
    /** An entryPointId for respective task */
    entryPointId: string;
    /** A valid customer DN, on which the response is expected, maximum length 36 characters */
    destination: string;
    /** The direction of the call */
    direction: 'OUTBOUND';
    /** Schema-free data tuples to pass specific data based on outboundType (max 30 tuples) */
    attributes: {
        [key: string]: string;
    };
    /** The media type for the request */
    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;
};
/**
 * Payload for campaign preview contact operations (accept, skip, remove)
 * @public
 */
export type PreviewContactPayload = {
    /** The interaction ID from the campaign reservation */
    interactionId: string;
    /** The campaign name (not a UUID). Available from the reservation event at
     *  `task.data.interaction.callProcessingDetails.campaignId` or `task.data.campaignId`. */
    campaignId: string;
};
/**
 * Data structure for cleaning up contact resources
 * @public
 */
export type ContactCleanupData = {
    /** Type of cleanup operation being performed */
    type: string;
    /** Organization identifier where cleanup is occurring */
    orgId: string;
    /** Identifier of the agent associated with the contacts */
    agentId: string;
    /** Detailed data about the cleanup operation */
    data: {
        /** Type of event that triggered the cleanup */
        eventType: string;
        /** Identifier of the interaction being cleaned up */
        interactionId: string;
        /** Organization identifier */
        orgId: string;
        /** Media manager handling the cleanup */
        mediaMgr: string;
        /** Tracking identifier for the cleanup operation */
        trackingId: string;
        /** Type of media being cleaned up */
        mediaType: string;
        /** Optional destination information */
        destination?: string;
        /** Whether this is a broadcast cleanup */
        broadcast: boolean;
        /** Type of cleanup being performed */
        type: string;
    };
};
/**
 * Response type for task public methods
 * Can be an {@link AgentContact} object containing updated task state,
 * an Error in case of failure, or void for operations that don't return data
 * @public
 */
export type TaskResponse = AgentContact | Error | void;
/**
 * Interface for managing task-related operations in the contact center
 * Extends EventEmitter to support event-driven task updates
 */
export interface ITask extends EventEmitter {
    /**
     * Event data received in the Contact Center events.
     * Contains detailed task information including interaction details, media resources,
     * and participant data as defined in {@link TaskData}
     */
    data: TaskData;
    /**
     * Map associating tasks with their corresponding call identifiers.
     */
    webCallMap: Record<TaskId, CallId>;
    /**
     * Auto-wrapup timer for the task
     * This is used to automatically wrap up tasks after a specified duration
     * as defined in {@link AutoWrapup}
     */
    autoWrapup?: AutoWrapup;
    /**
     * 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.
     * @ignore
     */
    unregisterWebCallListeners(): void;
    /**
     * Updates the task data with new information
     * @param newData - Updated task data to apply, must conform to {@link TaskData} structure
     * @returns Updated task instance
     * @ignore
     */
    updateTaskData(newData: TaskData): ITask;
    /**
     * Answers or accepts an incoming task.
     * Once accepted, the task will be assigned to the agent and trigger a {@link TASK_EVENTS.TASK_ASSIGNED} event.
     * The response will contain updated agent contact information as defined in {@link AgentContact}.
     * @returns Promise<TaskResponse>
     * @example
     * ```typescript
     * await task.accept();
     * ```
     */
    accept(): Promise<TaskResponse>;
    /**
     * Declines an incoming task for Browser Login
     * @returns Promise<TaskResponse>
     * @example
     * ```typescript
     * await task.decline();
     * ```
     */
    decline(): Promise<TaskResponse>;
    /**
     * 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
     * // Hold with default mediaResourceId
     * await task.hold();
     *
     * // Hold with custom mediaResourceId
     * await task.hold('custom-media-resource-id');
     * ```
     */
    hold(mediaResourceId?: string): Promise<TaskResponse>;
    /**
     * 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
     * // Resume with default mediaResourceId
     * await task.resume();
     *
     * // Resume with custom mediaResourceId
     * await task.resume('custom-media-resource-id');
     * ```
     */
    resume(mediaResourceId?: string): Promise<TaskResponse>;
    /**
     * Ends/terminates the current task.
     * @returns Promise<TaskResponse>
     * @example
     * ```typescript
     * await task.end();
     * ```
     */
    end(): Promise<TaskResponse>;
    /**
     * 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
     * await task.wrapup({
     *   wrapUpReason: "Customer issue resolved",
     *   auxCodeId: "RESOLVED"
     * });
     * ```
     */
    wrapup(wrapupPayload: WrapupPayLoad): Promise<TaskResponse>;
    /**
     * Pauses the recording for current task.
     * @returns Promise<TaskResponse>
     * @example
     * ```typescript
     * await task.pauseRecording();
     * ```
     */
    pauseRecording(): Promise<TaskResponse>;
    /**
     * Resumes a previously paused recording.
     * @param resumeRecordingPayload - Parameters for resuming the recording
     * @returns Promise<TaskResponse>
     * @example
     * ```typescript
     * 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>;
}