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

package/dist/services/task/state-machine/actions.js

@@ -0,0 +1,572 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.actions = void 0;
+exports.createInitialContext = createInitialContext;
+exports.getTaskStateForUiControls = void 0;
+exports.updateUIControls = updateUIControls;
+var _xstate = require("xstate");
+var _constants = require("./constants");
+var _types = require("../../config/types");
+var _uiControlsComputer = require("./uiControlsComputer");
+var _TaskUtils = require("../TaskUtils");
+var _guards = require("./guards");
+/**
+ * Task State Machine Actions - Action implementations executed during state transitions
+ */
+
+/** Terminal consult events that clear consult context in deriveTaskDataUpdates. */
+const CONSULT_CONTEXT_CLEAR_EVENTS = new Set([_types.CC_EVENTS.AGENT_CONSULT_ENDED, _types.CC_EVENTS.AGENT_CONSULT_FAILED]);
+const determineConsultInitiator = (taskData, selfAgentId) => {
+  if (!selfAgentId) return undefined;
+  if (taskData?.consultingAgentId) {
+    return taskData.consultingAgentId === selfAgentId;
+  }
+  if (taskData?.isConsulted === true) return false;
+  return undefined;
+};
+const deriveRecordingState = taskData => {
+  const callProcessingDetails = taskData?.interaction?.callProcessingDetails;
+  if (!callProcessingDetails) {
+    return {};
+  }
+  const update = {};
+  const {
+    recordingStarted,
+    recordInProgress,
+    isPaused
+  } = callProcessingDetails;
+  if (recordingStarted !== undefined) {
+    update.recordingControlsAvailable = recordingStarted;
+    if (!recordingStarted) {
+      update.recordingInProgress = false;
+    }
+  }
+  if (recordInProgress !== undefined) {
+    update.recordingControlsAvailable = recordInProgress || recordingStarted || false;
+    update.recordingInProgress = recordInProgress;
+  }
+  if (update.recordingControlsAvailable === undefined && update.recordingInProgress === undefined && recordingStarted) {
+    update.recordingControlsAvailable = true;
+    update.recordingInProgress = true;
+  }
+  if (isPaused !== undefined) {
+    update.recordingControlsAvailable = true;
+    update.recordingInProgress = !isPaused;
+  }
+  return update;
+};
+const isActiveConsultState = (taskData, selfAgentId) => {
+  if (taskData?.interaction?.state === _constants.INTERACTION_STATE.CONSULTING) return true;
+  if (selfAgentId) {
+    const selfParticipant = taskData?.interaction?.participants?.[selfAgentId];
+    const hasConsultMedia = Object.values(taskData?.interaction?.media ?? {}).some(media => media?.mType === _constants.MEDIA_TYPE_CONSULT);
+    // Pending consult before destination joins stays HELD, not CONSULTING.
+    if (selfParticipant?.consultState === 'consultInitiated' && !hasJoinedConsultDestination(taskData, selfAgentId) && hasConsultMedia && taskData?.isConsulted === false) {
+      return false;
+    }
+    if ((selfParticipant?.consultState === _constants.CONSULT_STATE.CONSULTING || selfParticipant?.consultState === _constants.CONSULT_STATE.CONFERENCING) && hasConsultMedia && taskData?.isConsulted === false) {
+      return true;
+    }
+  }
+  if (taskData?.interaction?.state === _constants.INTERACTION_STATE.POST_CALL && selfAgentId) {
+    const selfParticipant = taskData.interaction?.participants?.[selfAgentId];
+    const hasConsultMedia = Object.values(taskData.interaction?.media ?? {}).some(media => media?.mType === _constants.MEDIA_TYPE_CONSULT);
+    if (selfParticipant?.consultState === _constants.CONSULT_STATE.CONSULTING && hasConsultMedia) return true;
+  }
+  return false;
+};
+const isSelfConsultingOrPending = (taskData, selfAgentId) => {
+  if (!taskData || !selfAgentId) return false;
+  const selfParticipant = taskData?.interaction?.participants?.[selfAgentId];
+  return selfParticipant?.consultState === _constants.CONSULT_STATE.CONSULTING || selfParticipant?.consultState === _constants.CONSULT_STATE.CONFERENCING || selfParticipant?.consultState === 'consultInitiated';
+};
+const isDnOnConsultMedia = (taskData, selfAgentId) => {
+  if (!taskData?.interaction?.participants) return false;
+  const consultMedia = taskData.consultMediaResourceId ? taskData.interaction.media?.[taskData.consultMediaResourceId] : Object.values(taskData.interaction.media ?? {}).find(m => m?.mType === _constants.MEDIA_TYPE_CONSULT);
+  const consultParticipantIds = new Set(consultMedia?.participants ?? []);
+  if (consultParticipantIds.size === 0) return false;
+  return Object.values(taskData.interaction.participants).some(p => {
+    if (!p || p.hasLeft || p.id === selfAgentId) return false;
+    if (!consultParticipantIds.has(p.id)) return false;
+    const pType = String(p.pType ?? '').toUpperCase();
+    return pType === 'DN' || pType === 'EP-DN' || pType === 'EP_DN';
+  });
+};
+const mapConsultDestinationType = destinationType => {
+  if (!destinationType) return undefined;
+  const normalized = String(destinationType).toUpperCase();
+  if (normalized === 'DN' || normalized === 'EP-DN' || normalized === 'EP_DN') {
+    return 'entryPoint';
+  }
+  return destinationType;
+};
+const hasJoinedConsultDestination = (taskData, selfAgentId) => {
+  if (!taskData?.interaction) return false;
+  const participants = taskData.interaction.participants;
+  const cpd = taskData.interaction.callProcessingDetails;
+  const backendSaysJoined = cpd?.consultDestinationAgentJoined === 'true';
+  if (backendSaysJoined) return true;
+  if (!participants) return false;
+  const effectiveSelfAgentId = selfAgentId ?? taskData.agentId;
+  const selfParticipant = effectiveSelfAgentId ? participants[effectiveSelfAgentId] : undefined;
+  if (taskData.type === 'AgentConsulting' && selfParticipant?.consultState === _constants.CONSULT_STATE.CONSULTING && taskData.isConsulted === false && isDnOnConsultMedia(taskData, effectiveSelfAgentId)) {
+    return true;
+  }
+  return Object.values(participants).some(p => {
+    if (!p || p.isConsulted !== true || p.hasLeft) return false;
+    return p.hasJoined === true || p.consultState === _constants.CONSULT_STATE.CONSULTING;
+  });
+};
+const deriveConsultCallHeldFromTaskData = taskData => {
+  if (!taskData?.interaction) return undefined;
+  const eventType = taskData.type;
+  if (eventType === 'AgentContactHeld') return true;
+  if (eventType === 'AgentContactUnheld') return false;
+  const consultMediaId = taskData.consultMediaResourceId;
+  const consultMedia = consultMediaId ? taskData.interaction.media?.[consultMediaId] : Object.values(taskData.interaction.media ?? {}).find(m => m?.mType === _constants.MEDIA_TYPE_CONSULT);
+  if (!consultMedia) return undefined;
+  return Boolean(consultMedia.isHold);
+};
+const getTaskStateForUiControls = (taskData, selfAgentId) => {
+  if (!taskData?.interaction) {
+    return _constants.TaskState.IDLE;
+  }
+  if (taskData.interaction.isTerminated === true) {
+    return _constants.TaskState.WRAPPING_UP;
+  }
+
+  // EP-DN consult merged to conference before Agent 2 joins main — UI is conferencing (CAI-8329).
+  if ((0, _TaskUtils.isEpDnConsultPendingConferenceMerge)(taskData, selfAgentId)) {
+    return _constants.TaskState.CONFERENCING;
+  }
+  if (isActiveConsultState(taskData, selfAgentId)) {
+    return _constants.TaskState.CONSULTING;
+  }
+  if (taskData.interaction.state === _constants.INTERACTION_STATE.CONFERENCE || (0, _TaskUtils.getIsConferenceInProgress)(taskData)) {
+    return _constants.TaskState.CONFERENCING;
+  }
+  const mainMediaId = taskData.interaction.mainInteractionId || taskData.interactionId;
+  const isMainHeld = Boolean(mainMediaId && taskData.interaction.media?.[mainMediaId]?.isHold === true);
+  if (taskData.interaction.state === 'hold' || isMainHeld) {
+    return _constants.TaskState.HELD;
+  }
+  return _constants.TaskState.CONNECTED;
+};
+exports.getTaskStateForUiControls = getTaskStateForUiControls;
+const deriveTaskDataUpdates = (context, taskData) => taskData ? (() => {
+  const enrichedTaskData = taskData.type === 'AgentConsultCreated' && taskData.agentId ? {
+    ...taskData,
+    consultingAgentId: taskData.agentId
+  } : taskData;
+  const updates = {
+    taskData: enrichedTaskData,
+    ...deriveRecordingState(enrichedTaskData)
+  };
+  const selfAgentId = context.uiControlConfig.agentId ?? enrichedTaskData?.agentId;
+  const consultingActive = isActiveConsultState(enrichedTaskData, selfAgentId) || (0, _guards.hasActiveConsultInPostCall)(enrichedTaskData, selfAgentId);
+  const conferenceFromPayload = enrichedTaskData?.interaction?.state === _constants.INTERACTION_STATE.CONFERENCE || (0, _TaskUtils.getIsConferenceInProgress)(enrichedTaskData);
+  const selfConsultingOrPending = isSelfConsultingOrPending(enrichedTaskData, selfAgentId);
+  const inferredConsultingInitiator = selfConsultingOrPending && enrichedTaskData?.isConsulted === false;
+  if (enrichedTaskData.destAgentId) {
+    const isEpDnWithStoredId = context.consultDestinationType === 'entryPoint' && context.consultDestinationAgentId;
+    if (!isEpDnWithStoredId) {
+      updates.consultDestinationAgentId = enrichedTaskData.destAgentId;
+    }
+  }
+  const isConsultTerminalEvent = enrichedTaskData.type != null && CONSULT_CONTEXT_CLEAR_EVENTS.has(enrichedTaskData.type);
+  const epDnPendingMergeActive = (0, _TaskUtils.isEpDnConsultPendingConferenceMerge)(enrichedTaskData, selfAgentId);
+  if (isConsultTerminalEvent && !epDnPendingMergeActive) {
+    updates.consultInitiator = false;
+    updates.consultFromConference = false;
+    updates.consultDestinationAgentJoined = false;
+    updates.consultCallHeld = false;
+    updates.consultDestinationType = null;
+    updates.consultDestinationAgentId = null;
+    updates.transferConferenceRequested = false;
+    updates.hideBlindTransferForEpDnPendingMerge = false;
+  }
+  updates.hideBlindTransferForEpDnPendingMerge = (0, _TaskUtils.isEpDnConsultPendingConferenceMerge)(enrichedTaskData, selfAgentId);
+  if (consultingActive && enrichedTaskData.destinationType) {
+    updates.consultDestinationType = mapConsultDestinationType(enrichedTaskData.destinationType);
+  }
+  if (!isConsultTerminalEvent) {
+    const consultInitiator = determineConsultInitiator(enrichedTaskData, selfAgentId);
+    if (consultInitiator !== undefined) {
+      updates.consultInitiator = consultInitiator;
+    } else if (enrichedTaskData.type === 'AgentConsultCreated' && enrichedTaskData.agentId && enrichedTaskData.agentId !== selfAgentId && conferenceFromPayload) {
+      updates.consultInitiator = false;
+    } else if (!context.consultInitiator) {
+      if (inferredConsultingInitiator || consultingActive && enrichedTaskData.isConsulted === false) {
+        updates.consultInitiator = true;
+      }
+    }
+  }
+  const effectiveConsultInitiator = updates.consultInitiator ?? context.consultInitiator;
+  if (!isConsultTerminalEvent && effectiveConsultInitiator && conferenceFromPayload && (consultingActive || selfConsultingOrPending || Boolean(enrichedTaskData?.consultMediaResourceId))) {
+    updates.consultFromConference = true;
+  }
+  if (!isConsultTerminalEvent && (consultingActive || selfConsultingOrPending) && enrichedTaskData.interaction) {
+    const joinedConsultee = hasJoinedConsultDestination(enrichedTaskData, selfAgentId);
+    const selfParticipant = selfAgentId ? enrichedTaskData.interaction.participants?.[selfAgentId] : undefined;
+    const agentConsultingSelfJoined = enrichedTaskData.type === 'AgentConsulting' && effectiveConsultInitiator && selfParticipant?.consultState === _constants.CONSULT_STATE.CONSULTING;
+    if (joinedConsultee || agentConsultingSelfJoined) {
+      updates.consultDestinationAgentJoined = true;
+    } else if (selfParticipant?.consultState === 'consultInitiated') {
+      updates.consultDestinationAgentJoined = false;
+    }
+    if (!context.consultDestinationType && !updates.consultDestinationType) {
+      const hasEpDnParticipant = Boolean(enrichedTaskData.interaction.participants && Object.values(enrichedTaskData.interaction.participants).some(p => {
+        if (p?.hasLeft) return false;
+        const pType = String(p?.pType ?? '').toUpperCase();
+        return pType === 'EP-DN' || pType === 'EP_DN' || pType === 'DN';
+      }));
+      if (hasEpDnParticipant) updates.consultDestinationType = 'entryPoint';
+    }
+    if (effectiveConsultInitiator) {
+      const consultCallHeld = deriveConsultCallHeldFromTaskData(enrichedTaskData);
+      if (consultCallHeld !== undefined) {
+        updates.consultCallHeld = consultCallHeld;
+      }
+    }
+  }
+  const nextContext = {
+    ...context,
+    ...updates
+  };
+  const inferredState = getTaskStateForUiControls(enrichedTaskData, selfAgentId);
+  updates.uiControls = (0, _uiControlsComputer.computeUIControls)(inferredState, nextContext, enrichedTaskData);
+  return updates;
+})() : {};
+const getTaskDataFromEvent = event => event && typeof event === 'object' ? event.taskData : undefined;
+function createInitialContext(uiControlConfig, initialState = _constants.TaskState.IDLE) {
+  const baseContext = {
+    taskData: null,
+    consultInitiator: false,
+    exitingConference: false,
+    consultFromConference: false,
+    transferConferenceRequested: false,
+    consultDestinationType: null,
+    consultDestinationAgentId: null,
+    consultDestinationAgentJoined: false,
+    consultCallHeld: false,
+    hideBlindTransferForEpDnPendingMerge: false,
+    recordingControlsAvailable: false,
+    recordingInProgress: false,
+    uiControlConfig,
+    uiControls: (0, _uiControlsComputer.getDefaultUIControls)()
+  };
+  baseContext.uiControls = (0, _uiControlsComputer.computeUIControls)(initialState, baseContext);
+  return baseContext;
+}
+function updateUIControls(currentState) {
+  return (0, _xstate.assign)(({
+    context
+  }) => ({
+    uiControls: (0, _uiControlsComputer.computeUIControls)(currentState, context, context.taskData ?? undefined)
+  }));
+}
+const actions = exports.actions = {
+  initializeTask: (0, _xstate.assign)(({
+    context,
+    event
+  }) => {
+    return {
+      consultInitiator: false,
+      exitingConference: false,
+      consultDestinationType: null,
+      consultDestinationAgentJoined: false,
+      ...deriveTaskDataUpdates(context, getTaskDataFromEvent(event))
+    };
+  }),
+  /**
+   * Update task data from ASSIGN event
+   */
+  updateTaskData: (0, _xstate.assign)(({
+    context,
+    event
+  }) => {
+    return deriveTaskDataUpdates(context, getTaskDataFromEvent(event));
+  }),
+  /**
+   * Set consult initiator flag
+   *
+   * IMPORTANT: This action is called for CONSULT (user action) and CONSULT_CREATED (backend event).
+   * For CONSULT (user action): The user explicitly clicked Consult, so they ARE the initiator.
+   * For CONSULT_CREATED (backend event): Check taskData.isConsulted to determine if this agent
+   * is the initiator. If isConsulted === true, this is Agent B (the consulted party), NOT the initiator.
+   *
+   * This prevents all agents in a conference from becoming consultInitiator when one agent
+   * starts a new consult.
+   */
+  setConsultInitiator: (0, _xstate.assign)(({
+    event
+  }) => {
+    const taskData = getTaskDataFromEvent(event);
+    if (event.type === _constants.TaskEvent.CONSULT) return {
+      consultInitiator: true
+    };
+    const selfAgentId = taskData?.agentId;
+    const consultInitiator = determineConsultInitiator(taskData, selfAgentId);
+    if (consultInitiator === true) return {
+      consultInitiator: true
+    };
+    if (consultInitiator === false) return {
+      consultInitiator: false
+    };
+    return {};
+  }),
+  handleConsultFailed: (0, _xstate.assign)(({
+    context,
+    event
+  }) => {
+    const taskData = getTaskDataFromEvent(event) ?? context.taskData;
+    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
+    const hideBlindTransferForEpDnPendingMerge = (0, _TaskUtils.isEpDnConsultPendingConferenceMerge)(taskData, selfAgentId);
+    const cleared = {
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultInitiator: false,
+      exitingConference: false,
+      consultCallHeld: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      hideBlindTransferForEpDnPendingMerge
+    };
+    const nextContext = {
+      ...context,
+      ...cleared,
+      taskData
+    };
+    const inferredState = getTaskStateForUiControls(taskData, selfAgentId);
+    return {
+      ...cleared,
+      uiControls: (0, _uiControlsComputer.computeUIControls)(inferredState, nextContext, taskData)
+    };
+  }),
+  handleConferenceStarted: (0, _xstate.assign)({
+    consultInitiator: false
+  }),
+  setConsultDestination: (0, _xstate.assign)(({
+    context,
+    event
+  }) => {
+    if (!event || event.type !== _constants.TaskEvent.CONSULT) {
+      return {};
+    }
+
+    // CONSULT is a user action and does not carry taskData. Preserve the current interaction
+    // snapshot while recording the destination; replacing it with only destAgentId would remove
+    // the main-leg membership needed to correlate an immediately following lifecycle event.
+    const taskData = context.taskData;
+    const consultDestinationType = 'destinationType' in event ? event.destinationType ?? null : null;
+    const consultDestinationAgentId = ('destAgentId' in event ? event.destAgentId : null) ?? ('destination' in event ? event.destination : null) ?? null;
+    return {
+      consultDestinationType,
+      consultDestinationAgentId,
+      consultDestinationAgentJoined: false,
+      consultFromConference: false,
+      taskData: {
+        ...taskData,
+        destAgentId: consultDestinationAgentId
+      }
+    };
+  }),
+  setConsultFromConference: (0, _xstate.assign)({
+    consultFromConference: true
+  }),
+  forceConsultInitiator: (0, _xstate.assign)({
+    consultInitiator: true
+  }),
+  setConsultAgentJoined: (0, _xstate.assign)(({
+    context,
+    event
+  }) => {
+    if (context.consultDestinationAgentJoined) {
+      return {};
+    }
+    if (!event || event.type !== _constants.TaskEvent.CONSULTING_ACTIVE || !('consultDestinationAgentJoined' in event)) {
+      return {};
+    }
+    const eventValue = event.consultDestinationAgentJoined;
+    return eventValue ? {
+      consultDestinationAgentJoined: true
+    } : {};
+  }),
+  setRecordingState: (0, _xstate.assign)(({
+    event
+  }) => {
+    if (!event || !('type' in event)) {
+      return {};
+    }
+    if (event.type === _constants.TaskEvent.PAUSE_RECORDING) {
+      return {
+        recordingControlsAvailable: true,
+        recordingInProgress: false
+      };
+    }
+    if (event.type === _constants.TaskEvent.RESUME_RECORDING) {
+      return {
+        recordingControlsAvailable: true,
+        recordingInProgress: true
+      };
+    }
+    return {};
+  }),
+  clearConsultState: (0, _xstate.assign)(({
+    context,
+    event
+  }) => {
+    const taskData = context.taskData ?? getTaskDataFromEvent(event);
+    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
+    const hideBlindTransferForEpDnPendingMerge = (0, _TaskUtils.isEpDnConsultPendingConferenceMerge)(taskData, selfAgentId);
+    const cleared = {
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultInitiator: false,
+      exitingConference: false,
+      consultCallHeld: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      hideBlindTransferForEpDnPendingMerge
+    };
+    const nextContext = {
+      ...context,
+      ...cleared,
+      taskData
+    };
+    const inferredState = getTaskStateForUiControls(taskData, selfAgentId);
+    return {
+      ...cleared,
+      uiControls: (0, _uiControlsComputer.computeUIControls)(inferredState, nextContext, taskData)
+    };
+  }),
+  setTransferConferenceRequested: (0, _xstate.assign)({
+    transferConferenceRequested: true
+  }),
+  clearTransferConferenceRequested: (0, _xstate.assign)({
+    transferConferenceRequested: false
+  }),
+  setConsultCallHeld: (0, _xstate.assign)({
+    consultCallHeld: true
+  }),
+  clearConsultCallHeld: (0, _xstate.assign)({
+    consultCallHeld: false
+  }),
+  handleSwitchToMainCall: (0, _xstate.assign)({
+    consultCallHeld: true
+  }),
+  handleSwitchToConsult: (0, _xstate.assign)({
+    consultCallHeld: false
+  }),
+  handleConferenceFailed: (0, _xstate.assign)(({
+    event
+  }) => {
+    const taskData = getTaskDataFromEvent(event);
+    return taskData ? {
+      taskData
+    } : {};
+  }),
+  handleParticipantLeft: (0, _xstate.assign)(({
+    event
+  }) => {
+    const taskData = getTaskDataFromEvent(event);
+    return taskData ? {
+      taskData
+    } : {};
+  }),
+  setExitingConference: (0, _xstate.assign)({
+    exitingConference: true
+  }),
+  handleTransferConferenceSuccess: (0, _xstate.assign)(({
+    event
+  }) => {
+    const taskData = getTaskDataFromEvent(event);
+    return taskData ? {
+      taskData
+    } : {};
+  }),
+  setHoldState: (0, _xstate.assign)(({
+    context,
+    event
+  }) => {
+    if (!event || event.type !== _constants.TaskEvent.HOLD_SUCCESS && event.type !== _constants.TaskEvent.UNHOLD_SUCCESS) {
+      return {};
+    }
+    const mediaResourceId = 'mediaResourceId' in event ? event.mediaResourceId : undefined;
+    if (!mediaResourceId) {
+      return {};
+    }
+    const interaction = context.taskData?.interaction;
+    const mediaEntry = interaction?.media?.[mediaResourceId];
+    if (!interaction || !mediaEntry) {
+      return {};
+    }
+    const updatedMedia = {
+      ...interaction.media,
+      [mediaResourceId]: {
+        ...mediaEntry,
+        isHold: event.type === _constants.TaskEvent.HOLD_SUCCESS
+      }
+    };
+    const updates = {
+      taskData: {
+        ...context.taskData,
+        interaction: {
+          ...interaction,
+          media: updatedMedia
+        }
+      }
+    };
+    const consultMediaId = context.taskData?.consultMediaResourceId;
+    const isConsultMedia = consultMediaId ? mediaResourceId === consultMediaId : mediaEntry?.mType === 'consult';
+    if (isConsultMedia && context.consultInitiator) {
+      updates.consultCallHeld = event.type === _constants.TaskEvent.HOLD_SUCCESS;
+    }
+    return updates;
+  }),
+  markEnded: (0, _xstate.assign)(() => ({
+    recordingControlsAvailable: false,
+    recordingInProgress: false
+  })),
+  requestAutoAnswer: () => undefined,
+  requestCleanup: () => undefined,
+  cleanupResources: () => undefined,
+  // Event emitters - placeholders overridden by consumers
+  emitTaskCampaignPreviewReservation: () => undefined,
+  emitTaskCampaignPreviewAcceptFailed: () => undefined,
+  emitTaskCampaignPreviewSkipFailed: () => undefined,
+  emitTaskCampaignPreviewRemoveFailed: () => undefined,
+  emitTaskIncoming: () => undefined,
+  emitTaskHydrate: () => undefined,
+  emitTaskOfferContact: () => undefined,
+  emitTaskAssigned: () => undefined,
+  emitTaskHold: () => undefined,
+  emitTaskResume: () => undefined,
+  emitTaskEnd: () => undefined,
+  emitTaskOfferConsult: () => undefined,
+  emitTaskConsultCreated: () => undefined,
+  emitTaskConsulting: () => undefined,
+  emitTaskConsultAccepted: () => undefined,
+  emitTaskConsultEnd: () => undefined,
+  emitTaskReject: () => undefined,
+  emitTaskWrapup: () => undefined,
+  emitTaskRecordingStarted: () => undefined,
+  emitTaskRecordingPaused: () => undefined,
+  emitTaskRecordingResumed: () => undefined,
+  emitTaskWrappedup: () => undefined,
+  emitTaskParticipantLeft: () => undefined,
+  emitTaskConferenceStarted: () => undefined,
+  emitTaskConferenceEnded: () => undefined,
+  emitTaskExitConference: () => undefined,
+  emitTaskTransferConference: () => undefined,
+  emitTaskSwitchCall: () => undefined,
+  emitTaskConferenceFailed: () => undefined,
+  emitTaskTransferConferenceFailed: () => undefined,
+  emitTaskOutdialFailed: () => undefined
+};
+//# sourceMappingURL=actions.js.map