Class Task`Abstract`

Interface for managing task-related operations in the contact center Extends IEventEmitter to support event-driven task updates

Hierarchy

EventEmitter
- Task

Implements

ITask

Constructors

constructor

new Task(contact, data, uiControlConfig, wrapupData?, agentId?): Task
Parameters
- contact: {
      accept: Res<AgentContact, {
          interactionId: string;
      }>;
      blindTransfer: Res<AgentContact, {
          data: TransferPayLoad;
          interactionId: string;
      }>;
      cancelCtq: Res<AgentContact, {
          data: cancelCtq;
          interactionId: string;
      }>;
      cancelTask: Res<AgentContact, {
          interactionId: string;
      }>;
      conferenceTransfer: Res<AgentContact, {
          interactionId: string;
      }>;
      consult: Res<AgentContact, {
          data: ConsultPayload;
          interactionId: string;
      }>;
      consultAccept: Res<AgentContact, {
          interactionId: string;
      }>;
      consultConference: Res<AgentContact, {
          data: ConsultConferenceData;
          interactionId: string;
      }>;
      consultEnd: Res<AgentContact, {
          data: ConsultEndPayload;
          interactionId: string;
      }>;
      consultTransfer: Res<AgentContact, {
          data: ConsultTransferPayLoad;
          interactionId: string;
      }>;
      end: Res<AgentContact, {
          interactionId: string;
      }>;
      exitConference: Res<AgentContact, {
          interactionId: string;
      }>;
      hold: Res<AgentContact, {
          data: HoldResumePayload;
          interactionId: string;
      }>;
      pauseRecording: Res<AgentContact, {
          interactionId: string;
      }>;
      resumeRecording: Res<AgentContact, {
          data: ResumeRecordingPayload;
          interactionId: string;
      }>;
      unHold: Res<AgentContact, {
          data: HoldResumePayload;
          interactionId: string;
      }>;
      vteamTransfer: Res<AgentContact, {
          data: TransferPayLoad;
          interactionId: string;
      }>;
      wrapup: Res<AgentContact, {
          data: WrapupPayLoad;
          interactionId: string;
      }>;
  }
  - accept: Res<AgentContact, {
    interactionId: string;
    }>
  - blindTransfer: Res<AgentContact, {
    data: TransferPayLoad;
    interactionId: string;
    }>
  - cancelCtq: Res<AgentContact, {
    data: cancelCtq;
    interactionId: string;
    }>
  - cancelTask: Res<AgentContact, {
    interactionId: string;
    }>
  - conferenceTransfer: Res<AgentContact, {
    interactionId: string;
    }>
  - consult: Res<AgentContact, {
    data: ConsultPayload;
    interactionId: string;
    }>
  - consultAccept: Res<AgentContact, {
    interactionId: string;
    }>
  - consultConference: Res<AgentContact, {
    data: ConsultConferenceData;
    interactionId: string;
    }>
  - consultEnd: Res<AgentContact, {
    data: ConsultEndPayload;
    interactionId: string;
    }>
  - consultTransfer: Res<AgentContact, {
    data: ConsultTransferPayLoad;
    interactionId: string;
    }>
  - end: Res<AgentContact, {
    interactionId: string;
    }>
  - exitConference: Res<AgentContact, {
    interactionId: string;
    }>
  - hold: Res<AgentContact, {
    data: HoldResumePayload;
    interactionId: string;
    }>
  - pauseRecording: Res<AgentContact, {
    interactionId: string;
    }>
  - resumeRecording: Res<AgentContact, {
    data: ResumeRecordingPayload;
    interactionId: string;
    }>
  - unHold: Res<AgentContact, {
    data: HoldResumePayload;
    interactionId: string;
    }>
  - vteamTransfer: Res<AgentContact, {
    data: TransferPayLoad;
    interactionId: string;
    }>
  - wrapup: Res<AgentContact, {
    data: WrapupPayLoad;
    interactionId: string;
    }>
- data: TaskData
- uiControlConfig: UIControlConfigInput
- Optional wrapupData: WrapupData
- Optional agentId: string
Returns Task
Overrides EventEmitter.constructor
- Defined in services/task/Task.ts:65

Properties

`Optional` autoWrapup

autoWrapup?: default

Auto-wrapup timer for the task This is used to automatically wrap up tasks after a specified duration as defined in AutoWrapup

data

data: TaskData

Event data received in the Contact Center events. Contains detailed task information including interaction details, media resources, and participant data as defined in TaskData

`Optional` state

state?: MachineSnapshot<TaskContext, TaskEventPayload, Record<string, AnyActorRef>, IDLE | OFFERED | CONNECTED | HOLD_INITIATING | HELD | RESUME_INITIATING | CONSULT_INITIATING | CONSULTING | CONF_INITIATING | CONFERENCING | WRAPPING_UP | COMPLETED | TERMINATED, string, {}, MetaObject, {
    context: TaskContext;
    id: string;
    initial: TaskState;
    on: {
        CONTACT_OWNER_CHANGED: {
            actions: string[];
        };
        CONTACT_UPDATED: {
            actions: string[];
        };
        HYDRATE: {
            actions: string[];
        };
        RECORDING_STARTED: {
            actions: string[];
        };
    };
    states: {
        COMPLETED: {
            entry: string[];
            type: "final";
        };
        CONFERENCING: {
            on: {
                CONFERENCE_END: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                CONFERENCE_START: {
                    actions: string[];
                };
                CONSULT: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULT_END: {
                    actions: string[];
                };
                CONTACT_ENDED: {
                    actions: string[];
                }[];
                EXIT_CONFERENCE_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                HOLD_SUCCESS: {
                    actions: string[];
                };
                PARTICIPANT_LEAVE: ({
                    actions: string[];
                    guard: ((params) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target?: undefined;
                })[];
                TRANSFER_CONFERENCE: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_FAILED: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_SUCCESS: {
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                }[];
                UNHOLD_SUCCESS: {
                    actions: string[];
                };
            };
        };
        CONF_INITIATING: {
            on: {
                CONFERENCE_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                CONFERENCE_START: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        CONNECTED: {
            on: {
                ASSIGN: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULT: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULTING_ACTIVE: {
                    actions: string[];
                    target: TaskState;
                };
                CONTACT_ENDED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                HOLD_INITIATED: {
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
                PAUSE_RECORDING: {
                    actions: string[];
                };
                RESUME_RECORDING: {
                    actions: string[];
                };
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
                TRANSFER_FAILED: {
                    actions: string[];
                };
                TRANSFER_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target?: undefined;
                })[];
            };
        };
        CONSULTING: {
            on: {
                ASSIGN: {
                    actions: string[];
                    target: TaskState;
                };
                CONFERENCE_START: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULTING_ACTIVE: {
                    actions: string[];
                };
                CONSULT_END: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                CONTACT_ENDED: {
                    actions: string[];
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                };
                MERGE_TO_CONFERENCE: {
                    target: TaskState;
                };
                SWITCH_TO_CONSULT: {
                    actions: string[];
                };
                SWITCH_TO_MAIN_CALL: {
                    actions: string[];
                };
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
                TRANSFER_CONFERENCE: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_FAILED: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target?: undefined;
                } | {
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                TRANSFER_FAILED: {
                    actions: string[];
                };
                TRANSFER_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                UNHOLD_SUCCESS: {
                    actions: string[];
                };
            };
        };
        CONSULT_INITIATING: {
            on: {
                CONSULT_FAILED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                CONSULT_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
                CTQ_CANCEL: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                HOLD_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                };
            };
        };
        HELD: {
            on: {
                CONSULT: {
                    actions: string[];
                    target: TaskState;
                };
                CONTACT_ENDED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
                TRANSFER_FAILED: {
                    actions: string[];
                };
                TRANSFER_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                UNHOLD_INITIATED: {
                    target: TaskState;
                };
                UNHOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        HOLD_INITIATING: {
            on: {
                HOLD_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        IDLE: {
            on: {
                CONSULTING_ACTIVE: {
                    actions: string[];
                    target: TaskState;
                };
                HYDRATE: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target?: undefined;
                })[];
                TASK_INCOMING: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        OFFERED: {
            on: {
                ASSIGN: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                ASSIGN_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULTING_ACTIVE: {
                    actions: string[];
                    target: TaskState;
                }[];
                CONSULT_END: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULT_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                CONTACT_ENDED: {
                    actions: string[];
                    target: TaskState;
                };
                INVITE_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                OFFER_CONSULT: {
                    actions: string[];
                };
                OUTBOUND_FAILED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                RONA: {
                    actions: string[];
                    target: TaskState;
                };
                TASK_OFFERED: {
                    actions: string[];
                };
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        RESUME_INITIATING: {
            on: {
                UNHOLD_FAILED: {
                    target: TaskState;
                };
                UNHOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        TERMINATED: {
            entry: string[];
            type: "final";
        };
        WRAPPING_UP: {
            entry: string[];
            on: {
                WRAPUP_COMPLETE: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
    };
}>

Type declaration

context: TaskContext
id: string
initial: TaskState
on: {
    CONTACT_OWNER_CHANGED: {
        actions: string[];
    };
    CONTACT_UPDATED: {
        actions: string[];
    };
    HYDRATE: {
        actions: string[];
    };
    RECORDING_STARTED: {
        actions: string[];
    };
}
- CONTACT_OWNER_CHANGED: {
  actions: string[];
  }
  - actions: string[]
- CONTACT_UPDATED: {
  actions: string[];
  }
  - actions: string[]
- HYDRATE: {
  actions: string[];
  }
  - actions: string[]
- RECORDING_STARTED: {
  actions: string[];
  }
  - actions: string[]
states: {
    COMPLETED: {
        entry: string[];
        type: "final";
    };
    CONFERENCING: {
        on: {
            CONFERENCE_END: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            CONFERENCE_START: {
                actions: string[];
            };
            CONSULT: {
                actions: string[];
                target: TaskState;
            };
            CONSULT_END: {
                actions: string[];
            };
            CONTACT_ENDED: {
                actions: string[];
            }[];
            EXIT_CONFERENCE_SUCCESS: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            HOLD_SUCCESS: {
                actions: string[];
            };
            PARTICIPANT_LEAVE: ({
                actions: string[];
                guard: ((params) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target?: undefined;
            })[];
            TRANSFER_CONFERENCE: {
                actions: string[];
            };
            TRANSFER_CONFERENCE_FAILED: {
                actions: string[];
            };
            TRANSFER_CONFERENCE_SUCCESS: {
                actions: string[];
                guard: ((__namedParameters) => boolean);
            }[];
            UNHOLD_SUCCESS: {
                actions: string[];
            };
        };
    };
    CONF_INITIATING: {
        on: {
            CONFERENCE_FAILED: {
                actions: string[];
                target: TaskState;
            };
            CONFERENCE_START: {
                actions: string[];
                target: TaskState;
            };
        };
    };
    CONNECTED: {
        on: {
            ASSIGN: {
                actions: string[];
                target: TaskState;
            };
            CONSULT: {
                actions: string[];
                target: TaskState;
            };
            CONSULTING_ACTIVE: {
                actions: string[];
                target: TaskState;
            };
            CONTACT_ENDED: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            HOLD_INITIATED: {
                target: TaskState;
            };
            HOLD_SUCCESS: {
                actions: string[];
                target: TaskState;
            };
            PAUSE_RECORDING: {
                actions: string[];
            };
            RESUME_RECORDING: {
                actions: string[];
            };
            TASK_WRAPUP: {
                actions: string[];
                target: TaskState;
            };
            TRANSFER_FAILED: {
                actions: string[];
            };
            TRANSFER_SUCCESS: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target?: undefined;
            })[];
        };
    };
    CONSULTING: {
        on: {
            ASSIGN: {
                actions: string[];
                target: TaskState;
            };
            CONFERENCE_START: {
                actions: string[];
                target: TaskState;
            };
            CONSULTING_ACTIVE: {
                actions: string[];
            };
            CONSULT_END: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            CONTACT_ENDED: {
                actions: string[];
                target: TaskState;
            };
            HOLD_SUCCESS: {
                actions: string[];
            };
            MERGE_TO_CONFERENCE: {
                target: TaskState;
            };
            SWITCH_TO_CONSULT: {
                actions: string[];
            };
            SWITCH_TO_MAIN_CALL: {
                actions: string[];
            };
            TASK_WRAPUP: {
                actions: string[];
                target: TaskState;
            };
            TRANSFER_CONFERENCE: {
                actions: string[];
            };
            TRANSFER_CONFERENCE_FAILED: {
                actions: string[];
            };
            TRANSFER_CONFERENCE_SUCCESS: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target?: undefined;
            } | {
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            TRANSFER_FAILED: {
                actions: string[];
            };
            TRANSFER_SUCCESS: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            UNHOLD_SUCCESS: {
                actions: string[];
            };
        };
    };
    CONSULT_INITIATING: {
        on: {
            CONSULT_FAILED: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            CONSULT_SUCCESS: {
                actions: string[];
                target: TaskState;
            };
            CTQ_CANCEL: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            HOLD_FAILED: {
                actions: string[];
                target: TaskState;
            };
            HOLD_SUCCESS: {
                actions: string[];
            };
        };
    };
    HELD: {
        on: {
            CONSULT: {
                actions: string[];
                target: TaskState;
            };
            CONTACT_ENDED: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            TASK_WRAPUP: {
                actions: string[];
                target: TaskState;
            };
            TRANSFER_FAILED: {
                actions: string[];
            };
            TRANSFER_SUCCESS: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            UNHOLD_INITIATED: {
                target: TaskState;
            };
            UNHOLD_SUCCESS: {
                actions: string[];
                target: TaskState;
            };
        };
    };
    HOLD_INITIATING: {
        on: {
            HOLD_FAILED: {
                actions: string[];
                target: TaskState;
            };
            HOLD_SUCCESS: {
                actions: string[];
                target: TaskState;
            };
        };
    };
    IDLE: {
        on: {
            CONSULTING_ACTIVE: {
                actions: string[];
                target: TaskState;
            };
            HYDRATE: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target?: undefined;
            })[];
            TASK_INCOMING: {
                actions: string[];
                target: TaskState;
            };
        };
    };
    OFFERED: {
        on: {
            ASSIGN: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            ASSIGN_FAILED: {
                actions: string[];
                target: TaskState;
            };
            CONSULTING_ACTIVE: {
                actions: string[];
                target: TaskState;
            }[];
            CONSULT_END: {
                actions: string[];
                target: TaskState;
            };
            CONSULT_FAILED: {
                actions: string[];
                target: TaskState;
            };
            CONTACT_ENDED: {
                actions: string[];
                target: TaskState;
            };
            INVITE_FAILED: {
                actions: string[];
                target: TaskState;
            };
            OFFER_CONSULT: {
                actions: string[];
            };
            OUTBOUND_FAILED: ({
                actions: string[];
                guard: ((__namedParameters) => boolean);
                target: TaskState;
            } | {
                actions: string[];
                guard?: undefined;
                target: TaskState;
            })[];
            RONA: {
                actions: string[];
                target: TaskState;
            };
            TASK_OFFERED: {
                actions: string[];
            };
            TASK_WRAPUP: {
                actions: string[];
                target: TaskState;
            };
        };
    };
    RESUME_INITIATING: {
        on: {
            UNHOLD_FAILED: {
                target: TaskState;
            };
            UNHOLD_SUCCESS: {
                actions: string[];
                target: TaskState;
            };
        };
    };
    TERMINATED: {
        entry: string[];
        type: "final";
    };
    WRAPPING_UP: {
        entry: string[];
        on: {
            WRAPUP_COMPLETE: {
                actions: string[];
                target: TaskState;
            };
        };
    };
}
- COMPLETED: {
  entry: string[];
  type: "final";
  }
  - entry: string[]
  - type: "final"
- CONFERENCING: {
      on: {
          CONFERENCE_END: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          CONFERENCE_START: {
              actions: string[];
          };
          CONSULT: {
              actions: string[];
              target: TaskState;
          };
          CONSULT_END: {
              actions: string[];
          };
          CONTACT_ENDED: {
              actions: string[];
          }[];
          EXIT_CONFERENCE_SUCCESS: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          HOLD_SUCCESS: {
              actions: string[];
          };
          PARTICIPANT_LEAVE: ({
              actions: string[];
              guard: ((params) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target?: undefined;
          })[];
          TRANSFER_CONFERENCE: {
              actions: string[];
          };
          TRANSFER_CONFERENCE_FAILED: {
              actions: string[];
          };
          TRANSFER_CONFERENCE_SUCCESS: {
              actions: string[];
              guard: ((__namedParameters) => boolean);
          }[];
          UNHOLD_SUCCESS: {
              actions: string[];
          };
      };
  }
  - on: {
        CONFERENCE_END: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        CONFERENCE_START: {
            actions: string[];
        };
        CONSULT: {
            actions: string[];
            target: TaskState;
        };
        CONSULT_END: {
            actions: string[];
        };
        CONTACT_ENDED: {
            actions: string[];
        }[];
        EXIT_CONFERENCE_SUCCESS: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        HOLD_SUCCESS: {
            actions: string[];
        };
        PARTICIPANT_LEAVE: ({
            actions: string[];
            guard: ((params) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target?: undefined;
        })[];
        TRANSFER_CONFERENCE: {
            actions: string[];
        };
        TRANSFER_CONFERENCE_FAILED: {
            actions: string[];
        };
        TRANSFER_CONFERENCE_SUCCESS: {
            actions: string[];
            guard: ((__namedParameters) => boolean);
        }[];
        UNHOLD_SUCCESS: {
            actions: string[];
        };
    }
    - CONFERENCE_END: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - CONFERENCE_START: {
      actions: string[];
      }
      - actions: string[]
    - CONSULT: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONSULT_END: {
      actions: string[];
      }
      - actions: string[]
    - CONTACT_ENDED: {
      actions: string[];
      }[]
    - EXIT_CONFERENCE_SUCCESS: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - HOLD_SUCCESS: {
      actions: string[];
      }
      - actions: string[]
    - PARTICIPANT_LEAVE: ({
          actions: string[];
          guard: ((params) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target?: undefined;
      })[]
    - TRANSFER_CONFERENCE: {
      actions: string[];
      }
      - actions: string[]
    - TRANSFER_CONFERENCE_FAILED: {
      actions: string[];
      }
      - actions: string[]
    - TRANSFER_CONFERENCE_SUCCESS: {
      actions: string[];
      guard: ((__namedParameters) => boolean);
      }[]
    - UNHOLD_SUCCESS: {
      actions: string[];
      }
      - actions: string[]
- CONF_INITIATING: {
      on: {
          CONFERENCE_FAILED: {
              actions: string[];
              target: TaskState;
          };
          CONFERENCE_START: {
              actions: string[];
              target: TaskState;
          };
      };
  }
  - on: {
        CONFERENCE_FAILED: {
            actions: string[];
            target: TaskState;
        };
        CONFERENCE_START: {
            actions: string[];
            target: TaskState;
        };
    }
    - CONFERENCE_FAILED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONFERENCE_START: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
- CONNECTED: {
      on: {
          ASSIGN: {
              actions: string[];
              target: TaskState;
          };
          CONSULT: {
              actions: string[];
              target: TaskState;
          };
          CONSULTING_ACTIVE: {
              actions: string[];
              target: TaskState;
          };
          CONTACT_ENDED: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          HOLD_INITIATED: {
              target: TaskState;
          };
          HOLD_SUCCESS: {
              actions: string[];
              target: TaskState;
          };
          PAUSE_RECORDING: {
              actions: string[];
          };
          RESUME_RECORDING: {
              actions: string[];
          };
          TASK_WRAPUP: {
              actions: string[];
              target: TaskState;
          };
          TRANSFER_FAILED: {
              actions: string[];
          };
          TRANSFER_SUCCESS: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target?: undefined;
          })[];
      };
  }
  - on: {
        ASSIGN: {
            actions: string[];
            target: TaskState;
        };
        CONSULT: {
            actions: string[];
            target: TaskState;
        };
        CONSULTING_ACTIVE: {
            actions: string[];
            target: TaskState;
        };
        CONTACT_ENDED: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        HOLD_INITIATED: {
            target: TaskState;
        };
        HOLD_SUCCESS: {
            actions: string[];
            target: TaskState;
        };
        PAUSE_RECORDING: {
            actions: string[];
        };
        RESUME_RECORDING: {
            actions: string[];
        };
        TASK_WRAPUP: {
            actions: string[];
            target: TaskState;
        };
        TRANSFER_FAILED: {
            actions: string[];
        };
        TRANSFER_SUCCESS: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target?: undefined;
        })[];
    }
    - ASSIGN: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONSULT: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONSULTING_ACTIVE: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONTACT_ENDED: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - HOLD_INITIATED: {
      target: TaskState;
      }
      - target: TaskState
    - HOLD_SUCCESS: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - PAUSE_RECORDING: {
      actions: string[];
      }
      - actions: string[]
    - RESUME_RECORDING: {
      actions: string[];
      }
      - actions: string[]
    - TASK_WRAPUP: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - TRANSFER_FAILED: {
      actions: string[];
      }
      - actions: string[]
    - TRANSFER_SUCCESS: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target?: undefined;
      })[]
- CONSULTING: {
      on: {
          ASSIGN: {
              actions: string[];
              target: TaskState;
          };
          CONFERENCE_START: {
              actions: string[];
              target: TaskState;
          };
          CONSULTING_ACTIVE: {
              actions: string[];
          };
          CONSULT_END: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          CONTACT_ENDED: {
              actions: string[];
              target: TaskState;
          };
          HOLD_SUCCESS: {
              actions: string[];
          };
          MERGE_TO_CONFERENCE: {
              target: TaskState;
          };
          SWITCH_TO_CONSULT: {
              actions: string[];
          };
          SWITCH_TO_MAIN_CALL: {
              actions: string[];
          };
          TASK_WRAPUP: {
              actions: string[];
              target: TaskState;
          };
          TRANSFER_CONFERENCE: {
              actions: string[];
          };
          TRANSFER_CONFERENCE_FAILED: {
              actions: string[];
          };
          TRANSFER_CONFERENCE_SUCCESS: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target?: undefined;
          } | {
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          TRANSFER_FAILED: {
              actions: string[];
          };
          TRANSFER_SUCCESS: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          UNHOLD_SUCCESS: {
              actions: string[];
          };
      };
  }
  - on: {
        ASSIGN: {
            actions: string[];
            target: TaskState;
        };
        CONFERENCE_START: {
            actions: string[];
            target: TaskState;
        };
        CONSULTING_ACTIVE: {
            actions: string[];
        };
        CONSULT_END: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        CONTACT_ENDED: {
            actions: string[];
            target: TaskState;
        };
        HOLD_SUCCESS: {
            actions: string[];
        };
        MERGE_TO_CONFERENCE: {
            target: TaskState;
        };
        SWITCH_TO_CONSULT: {
            actions: string[];
        };
        SWITCH_TO_MAIN_CALL: {
            actions: string[];
        };
        TASK_WRAPUP: {
            actions: string[];
            target: TaskState;
        };
        TRANSFER_CONFERENCE: {
            actions: string[];
        };
        TRANSFER_CONFERENCE_FAILED: {
            actions: string[];
        };
        TRANSFER_CONFERENCE_SUCCESS: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target?: undefined;
        } | {
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        TRANSFER_FAILED: {
            actions: string[];
        };
        TRANSFER_SUCCESS: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        UNHOLD_SUCCESS: {
            actions: string[];
        };
    }
    - ASSIGN: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONFERENCE_START: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONSULTING_ACTIVE: {
      actions: string[];
      }
      - actions: string[]
    - CONSULT_END: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - CONTACT_ENDED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - HOLD_SUCCESS: {
      actions: string[];
      }
      - actions: string[]
    - MERGE_TO_CONFERENCE: {
      target: TaskState;
      }
      - target: TaskState
    - SWITCH_TO_CONSULT: {
      actions: string[];
      }
      - actions: string[]
    - SWITCH_TO_MAIN_CALL: {
      actions: string[];
      }
      - actions: string[]
    - TASK_WRAPUP: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - TRANSFER_CONFERENCE: {
      actions: string[];
      }
      - actions: string[]
    - TRANSFER_CONFERENCE_FAILED: {
      actions: string[];
      }
      - actions: string[]
    - TRANSFER_CONFERENCE_SUCCESS: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target?: undefined;
      } | {
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - TRANSFER_FAILED: {
      actions: string[];
      }
      - actions: string[]
    - TRANSFER_SUCCESS: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - UNHOLD_SUCCESS: {
      actions: string[];
      }
      - actions: string[]
- CONSULT_INITIATING: {
      on: {
          CONSULT_FAILED: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          CONSULT_SUCCESS: {
              actions: string[];
              target: TaskState;
          };
          CTQ_CANCEL: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          HOLD_FAILED: {
              actions: string[];
              target: TaskState;
          };
          HOLD_SUCCESS: {
              actions: string[];
          };
      };
  }
  - on: {
        CONSULT_FAILED: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        CONSULT_SUCCESS: {
            actions: string[];
            target: TaskState;
        };
        CTQ_CANCEL: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        HOLD_FAILED: {
            actions: string[];
            target: TaskState;
        };
        HOLD_SUCCESS: {
            actions: string[];
        };
    }
    - CONSULT_FAILED: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - CONSULT_SUCCESS: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CTQ_CANCEL: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - HOLD_FAILED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - HOLD_SUCCESS: {
      actions: string[];
      }
      - actions: string[]
- HELD: {
      on: {
          CONSULT: {
              actions: string[];
              target: TaskState;
          };
          CONTACT_ENDED: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          TASK_WRAPUP: {
              actions: string[];
              target: TaskState;
          };
          TRANSFER_FAILED: {
              actions: string[];
          };
          TRANSFER_SUCCESS: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          UNHOLD_INITIATED: {
              target: TaskState;
          };
          UNHOLD_SUCCESS: {
              actions: string[];
              target: TaskState;
          };
      };
  }
  - on: {
        CONSULT: {
            actions: string[];
            target: TaskState;
        };
        CONTACT_ENDED: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        TASK_WRAPUP: {
            actions: string[];
            target: TaskState;
        };
        TRANSFER_FAILED: {
            actions: string[];
        };
        TRANSFER_SUCCESS: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        UNHOLD_INITIATED: {
            target: TaskState;
        };
        UNHOLD_SUCCESS: {
            actions: string[];
            target: TaskState;
        };
    }
    - CONSULT: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONTACT_ENDED: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - TASK_WRAPUP: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - TRANSFER_FAILED: {
      actions: string[];
      }
      - actions: string[]
    - TRANSFER_SUCCESS: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - UNHOLD_INITIATED: {
      target: TaskState;
      }
      - target: TaskState
    - UNHOLD_SUCCESS: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
- HOLD_INITIATING: {
      on: {
          HOLD_FAILED: {
              actions: string[];
              target: TaskState;
          };
          HOLD_SUCCESS: {
              actions: string[];
              target: TaskState;
          };
      };
  }
  - on: {
        HOLD_FAILED: {
            actions: string[];
            target: TaskState;
        };
        HOLD_SUCCESS: {
            actions: string[];
            target: TaskState;
        };
    }
    - HOLD_FAILED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - HOLD_SUCCESS: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
- IDLE: {
      on: {
          CONSULTING_ACTIVE: {
              actions: string[];
              target: TaskState;
          };
          HYDRATE: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target?: undefined;
          })[];
          TASK_INCOMING: {
              actions: string[];
              target: TaskState;
          };
      };
  }
  - on: {
        CONSULTING_ACTIVE: {
            actions: string[];
            target: TaskState;
        };
        HYDRATE: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target?: undefined;
        })[];
        TASK_INCOMING: {
            actions: string[];
            target: TaskState;
        };
    }
    - CONSULTING_ACTIVE: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - HYDRATE: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target?: undefined;
      })[]
    - TASK_INCOMING: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
- OFFERED: {
      on: {
          ASSIGN: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          ASSIGN_FAILED: {
              actions: string[];
              target: TaskState;
          };
          CONSULTING_ACTIVE: {
              actions: string[];
              target: TaskState;
          }[];
          CONSULT_END: {
              actions: string[];
              target: TaskState;
          };
          CONSULT_FAILED: {
              actions: string[];
              target: TaskState;
          };
          CONTACT_ENDED: {
              actions: string[];
              target: TaskState;
          };
          INVITE_FAILED: {
              actions: string[];
              target: TaskState;
          };
          OFFER_CONSULT: {
              actions: string[];
          };
          OUTBOUND_FAILED: ({
              actions: string[];
              guard: ((__namedParameters) => boolean);
              target: TaskState;
          } | {
              actions: string[];
              guard?: undefined;
              target: TaskState;
          })[];
          RONA: {
              actions: string[];
              target: TaskState;
          };
          TASK_OFFERED: {
              actions: string[];
          };
          TASK_WRAPUP: {
              actions: string[];
              target: TaskState;
          };
      };
  }
  - on: {
        ASSIGN: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        ASSIGN_FAILED: {
            actions: string[];
            target: TaskState;
        };
        CONSULTING_ACTIVE: {
            actions: string[];
            target: TaskState;
        }[];
        CONSULT_END: {
            actions: string[];
            target: TaskState;
        };
        CONSULT_FAILED: {
            actions: string[];
            target: TaskState;
        };
        CONTACT_ENDED: {
            actions: string[];
            target: TaskState;
        };
        INVITE_FAILED: {
            actions: string[];
            target: TaskState;
        };
        OFFER_CONSULT: {
            actions: string[];
        };
        OUTBOUND_FAILED: ({
            actions: string[];
            guard: ((__namedParameters) => boolean);
            target: TaskState;
        } | {
            actions: string[];
            guard?: undefined;
            target: TaskState;
        })[];
        RONA: {
            actions: string[];
            target: TaskState;
        };
        TASK_OFFERED: {
            actions: string[];
        };
        TASK_WRAPUP: {
            actions: string[];
            target: TaskState;
        };
    }
    - ASSIGN: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - ASSIGN_FAILED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONSULTING_ACTIVE: {
      actions: string[];
      target: TaskState;
      }[]
    - CONSULT_END: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONSULT_FAILED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - CONTACT_ENDED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - INVITE_FAILED: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - OFFER_CONSULT: {
      actions: string[];
      }
      - actions: string[]
    - OUTBOUND_FAILED: ({
          actions: string[];
          guard: ((__namedParameters) => boolean);
          target: TaskState;
      } | {
          actions: string[];
          guard?: undefined;
          target: TaskState;
      })[]
    - RONA: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
    - TASK_OFFERED: {
      actions: string[];
      }
      - actions: string[]
    - TASK_WRAPUP: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
- RESUME_INITIATING: {
      on: {
          UNHOLD_FAILED: {
              target: TaskState;
          };
          UNHOLD_SUCCESS: {
              actions: string[];
              target: TaskState;
          };
      };
  }
  - on: {
        UNHOLD_FAILED: {
            target: TaskState;
        };
        UNHOLD_SUCCESS: {
            actions: string[];
            target: TaskState;
        };
    }
    - UNHOLD_FAILED: {
      target: TaskState;
      }
      - target: TaskState
    - UNHOLD_SUCCESS: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState
- TERMINATED: {
  entry: string[];
  type: "final";
  }
  - entry: string[]
  - type: "final"
- WRAPPING_UP: {
      entry: string[];
      on: {
          WRAPUP_COMPLETE: {
              actions: string[];
              target: TaskState;
          };
      };
  }
  - entry: string[]
  - on: {
        WRAPUP_COMPLETE: {
            actions: string[];
            target: TaskState;
        };
    }
    - WRAPUP_COMPLETE: {
      actions: string[];
      target: TaskState;
      }
      - actions: string[]
      - target: TaskState

`Optional` stateMachineService

stateMachineService?: ActorRef<MachineSnapshot<TaskContext, TaskEventPayload, Record<string, AnyActorRef>, IDLE | OFFERED | CONNECTED | HOLD_INITIATING | HELD | RESUME_INITIATING | CONSULT_INITIATING | CONSULTING | CONF_INITIATING | CONFERENCING | WRAPPING_UP | COMPLETED | TERMINATED, string, {}, MetaObject, {
    context: TaskContext;
    id: string;
    initial: TaskState;
    on: {
        CONTACT_OWNER_CHANGED: {
            actions: string[];
        };
        CONTACT_UPDATED: {
            actions: string[];
        };
        HYDRATE: {
            actions: string[];
        };
        RECORDING_STARTED: {
            actions: string[];
        };
    };
    states: {
        COMPLETED: {
            entry: string[];
            type: "final";
        };
        CONFERENCING: {
            on: {
                CONFERENCE_END: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                CONFERENCE_START: {
                    actions: string[];
                };
                CONSULT: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULT_END: {
                    actions: string[];
                };
                CONTACT_ENDED: {
                    actions: string[];
                }[];
                EXIT_CONFERENCE_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                HOLD_SUCCESS: {
                    actions: string[];
                };
                PARTICIPANT_LEAVE: ({
                    actions: string[];
                    guard: ((params) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target?: undefined;
                })[];
                TRANSFER_CONFERENCE: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_FAILED: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_SUCCESS: {
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                }[];
                UNHOLD_SUCCESS: {
                    actions: string[];
                };
            };
        };
        CONF_INITIATING: {
            on: {
                CONFERENCE_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                CONFERENCE_START: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        CONNECTED: {
            on: {
                ASSIGN: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULT: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULTING_ACTIVE: {
                    actions: string[];
                    target: TaskState;
                };
                CONTACT_ENDED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                HOLD_INITIATED: {
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
                PAUSE_RECORDING: {
                    actions: string[];
                };
                RESUME_RECORDING: {
                    actions: string[];
                };
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
                TRANSFER_FAILED: {
                    actions: string[];
                };
                TRANSFER_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target?: undefined;
                })[];
            };
        };
        CONSULTING: {
            on: {
                ASSIGN: {
                    actions: string[];
                    target: TaskState;
                };
                CONFERENCE_START: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULTING_ACTIVE: {
                    actions: string[];
                };
                CONSULT_END: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                CONTACT_ENDED: {
                    actions: string[];
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                };
                MERGE_TO_CONFERENCE: {
                    target: TaskState;
                };
                SWITCH_TO_CONSULT: {
                    actions: string[];
                };
                SWITCH_TO_MAIN_CALL: {
                    actions: string[];
                };
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
                TRANSFER_CONFERENCE: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_FAILED: {
                    actions: string[];
                };
                TRANSFER_CONFERENCE_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target?: undefined;
                } | {
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                TRANSFER_FAILED: {
                    actions: string[];
                };
                TRANSFER_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                UNHOLD_SUCCESS: {
                    actions: string[];
                };
            };
        };
        CONSULT_INITIATING: {
            on: {
                CONSULT_FAILED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                CONSULT_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
                CTQ_CANCEL: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                HOLD_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                };
            };
        };
        HELD: {
            on: {
                CONSULT: {
                    actions: string[];
                    target: TaskState;
                };
                CONTACT_ENDED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
                TRANSFER_FAILED: {
                    actions: string[];
                };
                TRANSFER_SUCCESS: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                UNHOLD_INITIATED: {
                    target: TaskState;
                };
                UNHOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        HOLD_INITIATING: {
            on: {
                HOLD_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                HOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        IDLE: {
            on: {
                CONSULTING_ACTIVE: {
                    actions: string[];
                    target: TaskState;
                };
                HYDRATE: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target?: undefined;
                })[];
                TASK_INCOMING: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        OFFERED: {
            on: {
                ASSIGN: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                ASSIGN_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULTING_ACTIVE: {
                    actions: string[];
                    target: TaskState;
                }[];
                CONSULT_END: {
                    actions: string[];
                    target: TaskState;
                };
                CONSULT_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                CONTACT_ENDED: {
                    actions: string[];
                    target: TaskState;
                };
                INVITE_FAILED: {
                    actions: string[];
                    target: TaskState;
                };
                OFFER_CONSULT: {
                    actions: string[];
                };
                OUTBOUND_FAILED: ({
                    actions: string[];
                    guard: ((__namedParameters) => boolean);
                    target: TaskState;
                } | {
                    actions: string[];
                    guard?: undefined;
                    target: TaskState;
                })[];
                RONA: {
                    actions: string[];
                    target: TaskState;
                };
                TASK_OFFERED: {
                    actions: string[];
                };
                TASK_WRAPUP: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        RESUME_INITIATING: {
            on: {
                UNHOLD_FAILED: {
                    target: TaskState;
                };
                UNHOLD_SUCCESS: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
        TERMINATED: {
            entry: string[];
            type: "final";
        };
        WRAPPING_UP: {
            entry: string[];
            on: {
                WRAPUP_COMPLETE: {
                    actions: string[];
                    target: TaskState;
                };
            };
        };
    };
}>, TaskEventPayload, EventObject>

webCallMap

webCallMap: Record<string, string>

Map associating tasks with their corresponding call identifiers.

`Protected` `Optional` agentId

agentId?: string

`Protected` contact

contact: {
    accept: Res<AgentContact, {
        interactionId: string;
    }>;
    blindTransfer: Res<AgentContact, {
        data: TransferPayLoad;
        interactionId: string;
    }>;
    cancelCtq: Res<AgentContact, {
        data: cancelCtq;
        interactionId: string;
    }>;
    cancelTask: Res<AgentContact, {
        interactionId: string;
    }>;
    conferenceTransfer: Res<AgentContact, {
        interactionId: string;
    }>;
    consult: Res<AgentContact, {
        data: ConsultPayload;
        interactionId: string;
    }>;
    consultAccept: Res<AgentContact, {
        interactionId: string;
    }>;
    consultConference: Res<AgentContact, {
        data: ConsultConferenceData;
        interactionId: string;
    }>;
    consultEnd: Res<AgentContact, {
        data: ConsultEndPayload;
        interactionId: string;
    }>;
    consultTransfer: Res<AgentContact, {
        data: ConsultTransferPayLoad;
        interactionId: string;
    }>;
    end: Res<AgentContact, {
        interactionId: string;
    }>;
    exitConference: Res<AgentContact, {
        interactionId: string;
    }>;
    hold: Res<AgentContact, {
        data: HoldResumePayload;
        interactionId: string;
    }>;
    pauseRecording: Res<AgentContact, {
        interactionId: string;
    }>;
    resumeRecording: Res<AgentContact, {
        data: ResumeRecordingPayload;
        interactionId: string;
    }>;
    unHold: Res<AgentContact, {
        data: HoldResumePayload;
        interactionId: string;
    }>;
    vteamTransfer: Res<AgentContact, {
        data: TransferPayLoad;
        interactionId: string;
    }>;
    wrapup: Res<AgentContact, {
        data: WrapupPayLoad;
        interactionId: string;
    }>;
}

Type declaration

accept: Res<AgentContact, {
interactionId: string;
}>
blindTransfer: Res<AgentContact, {
data: TransferPayLoad;
interactionId: string;
}>
cancelCtq: Res<AgentContact, {
data: cancelCtq;
interactionId: string;
}>
cancelTask: Res<AgentContact, {
interactionId: string;
}>
conferenceTransfer: Res<AgentContact, {
interactionId: string;
}>
consult: Res<AgentContact, {
data: ConsultPayload;
interactionId: string;
}>
consultAccept: Res<AgentContact, {
interactionId: string;
}>
consultConference: Res<AgentContact, {
data: ConsultConferenceData;
interactionId: string;
}>
consultEnd: Res<AgentContact, {
data: ConsultEndPayload;
interactionId: string;
}>
consultTransfer: Res<AgentContact, {
data: ConsultTransferPayLoad;
interactionId: string;
}>
end: Res<AgentContact, {
interactionId: string;
}>
exitConference: Res<AgentContact, {
interactionId: string;
}>
hold: Res<AgentContact, {
data: HoldResumePayload;
interactionId: string;
}>
pauseRecording: Res<AgentContact, {
interactionId: string;
}>
resumeRecording: Res<AgentContact, {
data: ResumeRecordingPayload;
interactionId: string;
}>
unHold: Res<AgentContact, {
data: HoldResumePayload;
interactionId: string;
}>
vteamTransfer: Res<AgentContact, {
data: TransferPayLoad;
interactionId: string;
}>
wrapup: Res<AgentContact, {
data: WrapupPayLoad;
interactionId: string;
}>

`Protected` currentUiControls

currentUiControls: TaskUIControls

`Protected` metricsManager

metricsManager: default

`Protected` uiControlConfig

uiControlConfig: UIControlConfig

`Protected` `Optional` wrapupData

wrapupData?: WrapupData

`Private` `Optional` lastState

lastState?: TaskState

Accessors

uiControls

get uiControls(): TaskUIControls
Latest UI controls derived from state machine state and context.

Returns TaskUIControls
Implementation of ITask.uiControls
- Defined in services/task/Task.ts:201

Methods

`Abstract` accept

accept(): Promise<TaskResponse>
Answers or accepts an incoming task. Once accepted, the task will be assigned to the agent and trigger a TASK_EVENTS.TASK_ASSIGNED event. The response will contain updated agent contact information as defined in AgentContact.

Returns Promise<TaskResponse>
Promise
Example
```
await task.accept();
```
Implementation of ITask.accept
- Defined in services/task/Task.ts:96

cancelAutoWrapupTimer

cancelAutoWrapupTimer(): void
Cancel any in-progress auto wrap-up timer. Base implementation just clears the timer reference so subclasses inherit the behavior.

Returns void
Implementation of ITask.cancelAutoWrapupTimer
- Defined in services/task/Task.ts:173

consult

consult(consultPayload): Promise<TaskResponse>
Initiates a consultation with another agent or queue.
Parameters
- consultPayload: ConsultPayload
  Consultation details including destination and type
Returns Promise<TaskResponse>
Promise
Example
```
await task.consult({ to: "agentId", destinationType: "agent" });
```
Implementation of ITask.consult
- Defined in services/task/Task.ts:117

consultConference

consultConference(): Promise<TaskResponse>
Initiates a consult conference (merge consult call with main call).

Returns Promise<TaskResponse>
Promise
Example
```
await task.consultConference();
```
Implementation of ITask.consultConference
- Defined in services/task/Task.ts:140

consultTransfer

consultTransfer(consultTransferPayload?): Promise<TaskResponse>
Parameters
- Optional consultTransferPayload: ConsultTransferPayLoad
Returns Promise<TaskResponse>
- Defined in services/task/Task.ts:131

decline

decline(): Promise<TaskResponse>
Declines an incoming task for Browser Login

Returns Promise<TaskResponse>
Promise
Example
```
await task.decline();
```
Implementation of ITask.decline
- Defined in services/task/Task.ts:100

end

end(): Promise<TaskResponse>
This is used to end the task.

Returns Promise<TaskResponse>
Promise
Throws
Error

Example
```
task.end().then(()=>{}).catch(()=>{})
```
Implementation of ITask.end
- Defined in services/task/Task.ts:677

endConsult

endConsult(consultEndPayload): Promise<TaskResponse>
Ends an ongoing consultation.
Parameters
- consultEndPayload: ConsultEndPayload
  Details for ending the consultation
Returns Promise<TaskResponse>
Promise
Example
```
await task.endConsult({ isConsult: true, taskId: "taskId" });
```
Implementation of ITask.endConsult
- Defined in services/task/Task.ts:124

exitConference

exitConference(): Promise<TaskResponse>
Exits from an ongoing conference.

Returns Promise<TaskResponse>
Promise
Example
```
await task.exitConference();
```
Implementation of ITask.exitConference
- Defined in services/task/Task.ts:144

hold

hold(): Promise<TaskResponse>

Places the current task on hold.

Returns Promise<TaskResponse>

Promise

Example

// Hold with default mediaResourceId
await task.hold();

// Hold with custom mediaResourceId
await task.hold('custom-media-resource-id');

holdResume

holdResume(): Promise<TaskResponse>
Returns Promise<TaskResponse>
- Defined in services/task/Task.ts:194

pauseRecording

pauseRecording(): Promise<TaskResponse>
Pauses the recording for current task.

Returns Promise<TaskResponse>
Promise
Example
```
await task.pauseRecording();
```
Implementation of ITask.pauseRecording
- Defined in services/task/Task.ts:104

resume

resume(): Promise<TaskResponse>

Resumes a task that was previously on hold.

Returns Promise<TaskResponse>

Promise

Example

// Resume with default mediaResourceId
await task.resume();

// Resume with custom mediaResourceId
await task.resume('custom-media-resource-id');

resumeRecording

resumeRecording(resumeRecordingPayload): Promise<TaskResponse>
Resumes a previously paused recording.
Parameters
- resumeRecordingPayload: ResumeRecordingPayload
  Parameters for resuming the recording
Returns Promise<TaskResponse>
Promise
Example
```
await task.resumeRecording({
  autoResumed: false
});
```
Implementation of ITask.resumeRecording
- Defined in services/task/Task.ts:108

sendStateMachineEvent

sendStateMachineEvent(event): void
Send an event to the state machine
Parameters
- event: TaskEventPayload
Returns void
Implementation of ITask.sendStateMachineEvent
- Defined in services/task/Task.ts:247

switchCall

switchCall(): Promise<TaskResponse>
Toggles between consult call and main call during consulting. If on consult leg, switches to main call (holds consult). If on main call, switches to consult (resumes consult). Only available when in CONSULTING state.

Returns Promise<TaskResponse>
Promise
Example
```
await task.switchCall();
```
Implementation of ITask.switchCall
- Defined in services/task/Task.ts:152

toggleMute

toggleMute(): Promise<void>
Toggles mute/unmute for the local audio stream during a WebRTC task.

Returns Promise<void>
Promise
Example
```
await task.toggleMute();
```
Implementation of ITask.toggleMute
- Defined in services/task/Task.ts:156

transfer

transfer(transferPayload): Promise<TaskResponse>
This is used to blind transfer or vTeam transfer the task
Parameters
- transferPayload: TransferPayLoad
Returns Promise<TaskResponse>
Promise
Throws
Error

Example
```
const transferPayload = {
 to: 'myQueueId',
 destinationType: 'queue',
}
task.transfer(transferPayload).then(()=>{}).catch(()=>{});
```
Implementation of ITask.transfer
- Defined in services/task/Task.ts:612

transferConference

transferConference(): Promise<TaskResponse>
Transfers the conference to another participant.

Returns Promise<TaskResponse>
Promise
Example
```
await task.transferConference();
```
Implementation of ITask.transferConference
- Defined in services/task/Task.ts:148

unregisterWebCallListeners

unregisterWebCallListeners(): void
Returns void
Implementation of ITask.unregisterWebCallListeners
- Defined in services/task/Task.ts:160

updateTaskData

updateTaskData(updatedData, shouldOverwrite?): ITask
This method is used to update the task data.
Parameters
- updatedData: TaskData
  TaskData
- shouldOverwrite: boolean = false
  boolean
Returns ITask
Example
```
task.updateTaskData(updatedData, true);
```
Implementation of ITask.updateTaskData
- Defined in services/task/Task.ts:590

wrapup

wrapup(wrapupPayload): Promise<TaskResponse>
This is used to wrap up the task.
Parameters
- wrapupPayload: WrapupPayLoad
  WrapupPayLoad
Returns Promise<TaskResponse>
Promise
Throws
Error

Example
```
task.wrapup(wrapupPayload).then(()=>{}).catch(()=>{})
```
Implementation of ITask.wrapup
- Defined in services/task/Task.ts:730

`Protected` computeUIControls

computeUIControls(): TaskUIControls
Compute UI controls based on current state machine state.

Returns TaskUIControls
UI control states for all task actions
- Defined in services/task/Task.ts:271

`Protected` createEmitSelfAction

createEmitSelfAction(taskEvent, __namedParameters?): ((__namedParameters) => void)
Parameters
- taskEvent: TASK_EVENTS
- __namedParameters: {
  updateTaskData?: boolean;
  } = {}
  - Optional updateTaskData?: boolean
Returns ((__namedParameters) => void)
- - (__namedParameters): void
  - Parameters
    - __namedParameters: TaskActionArgs
    Returns void
- Defined in services/task/Task.ts:390

`Protected` getChannelSpecificActionOverrides

getChannelSpecificActionOverrides(): Partial<TaskActionsMap>
Returns Partial<TaskActionsMap>
- Defined in services/task/Task.ts:386

`Protected` getCurrentState

getCurrentState(): TaskState
Get the current state machine state

Returns TaskState
- Defined in services/task/Task.ts:262

`Protected` getStateMachineActionOverrides

getStateMachineActionOverrides(): Partial<TaskActionsMap>
Returns Partial<TaskActionsMap>
- Defined in services/task/Task.ts:379

`Protected` setupAutoWrapupTimer

setupAutoWrapupTimer(): void
Sets up the automatic wrap-up timer if wrap-up is required

Returns void
- Defined in services/task/Task.ts:501

`Protected` stopStateMachine

stopStateMachine(): void
Stop the state machine service

Returns void
- Defined in services/task/Task.ts:287

`Protected` unsupportedMethodError

unsupportedMethodError(methodName): void
Parameters
- methodName: string
  The name of the method that is unsupported
Returns void
Throws
Error
- Defined in services/task/Task.ts:572

`Protected` updateUiControls

updateUiControls(forceEmit?): void
Parameters
- forceEmit: boolean = false
Returns void
- Defined in services/task/Task.ts:205

`Private` autoAnswerIfNeeded

autoAnswerIfNeeded(): Promise<void>
Returns Promise<void>
- Defined in services/task/Task.ts:306

`Static` `Private` extractTaskDataFromEvent

extractTaskDataFromEvent(event?): TaskData
Parameters
- Optional event: TaskEventPayload
Returns TaskData
- Defined in services/task/Task.ts:294

`Private` getCommonActionOverrides

getCommonActionOverrides(): Partial<TaskActionsMap>
Returns Partial<TaskActionsMap>
- Defined in services/task/Task.ts:407

`Private` initializeStateMachine

initializeStateMachine(): void
Initialize the state machine

Returns void
- Defined in services/task/Task.ts:218

`Private` reconcileData

reconcileData(oldData, newData): TaskData
Cancels the automatic wrap-up timer if it's running
Parameters
- oldData: TaskData
- newData: TaskData
Returns TaskData
- Defined in services/task/Task.ts:555

`Static` `Private` resolveChannelType

resolveChannelType(data): TaskChannelType
Parameters
- data: TaskData
Returns TaskChannelType
- Defined in services/task/Task.ts:87

`Private` updateTaskFromEvent

updateTaskFromEvent(event?): void
Parameters
- Optional event: TaskEventPayload
Returns void
- Defined in services/task/Task.ts:372

Class TaskAbstract

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

accept: Res<AgentContact, { interactionId: string; }>

blindTransfer: Res<AgentContact, { data: TransferPayLoad; interactionId: string; }>

cancelCtq: Res<AgentContact, { data: cancelCtq; interactionId: string; }>

cancelTask: Res<AgentContact, { interactionId: string; }>

conferenceTransfer: Res<AgentContact, { interactionId: string; }>

consult: Res<AgentContact, { data: ConsultPayload; interactionId: string; }>

consultAccept: Res<AgentContact, { interactionId: string; }>

consultConference: Res<AgentContact, { data: ConsultConferenceData; interactionId: string; }>

consultEnd: Res<AgentContact, { data: ConsultEndPayload; interactionId: string; }>

consultTransfer: Res<AgentContact, { data: ConsultTransferPayLoad; interactionId: string; }>

end: Res<AgentContact, { interactionId: string; }>

exitConference: Res<AgentContact, { interactionId: string; }>

hold: Res<AgentContact, { data: HoldResumePayload; interactionId: string; }>

pauseRecording: Res<AgentContact, { interactionId: string; }>

resumeRecording: Res<AgentContact, { data: ResumeRecordingPayload; interactionId: string; }>

unHold: Res<AgentContact, { data: HoldResumePayload; interactionId: string; }>

vteamTransfer: Res<AgentContact, { data: TransferPayLoad; interactionId: string; }>

wrapup: Res<AgentContact, { data: WrapupPayLoad; interactionId: string; }>

Returns Task

Properties

Optional autoWrapup

data

Optional state

Type declaration

Type declaration

context: TaskContext

id: string

initial: TaskState

on: { CONTACT_OWNER_CHANGED: { actions: string[]; }; CONTACT_UPDATED: { actions: string[]; }; HYDRATE: { actions: string[]; }; RECORDING_STARTED: { actions: string[]; }; }

CONTACT_OWNER_CHANGED: { actions: string[]; }

actions: string[]

CONTACT_UPDATED: { actions: string[]; }

actions: string[]

HYDRATE: { actions: string[]; }

actions: string[]

RECORDING_STARTED: { actions: string[]; }

actions: string[]

COMPLETED: { entry: string[]; type: "final"; }

entry: string[]

type: "final"

CONFERENCE_END: ({ actions: string[]; guard: ((__namedParameters) => boolean); target: TaskState; } | { actions: string[]; guard: ((__namedParameters) => boolean); target: TaskState; } | { actions: string[]; guard?: undefined; target: TaskState; })[]

CONFERENCE_START: { actions: string[]; }

actions: string[]

CONSULT: { actions: string[]; target: TaskState; }

actions: string[]

target: TaskState

CONSULT_END: { actions: string[]; }

actions: string[]

CONTACT_ENDED: { actions: string[]; }[]

EXIT_CONFERENCE_SUCCESS: ({ actions: string[]; guard: ((__namedParameters) => boolean); target: TaskState; } | { actions: string[]; guard?: undefined; target: TaskState; })[]

HOLD_SUCCESS: { actions: string[]; }

actions: string[]

PARTICIPANT_LEAVE: ({ actions: string[]; guard: ((params) => boolean); target: TaskState; } | { actions: string[]; guard?: undefined; target?: undefined; })[]

TRANSFER_CONFERENCE: { actions: string[]; }

actions: string[]

TRANSFER_CONFERENCE_FAILED: { actions: string[]; }

actions: string[]

TRANSFER_CONFERENCE_SUCCESS: { actions: string[]; guard: ((__namedParameters) => boolean); }[]

UNHOLD_SUCCESS: { actions: string[]; }

actions: string[]

CONF_INITIATING: { on: { CONFERENCE_FAILED: { actions: string[]; target: TaskState; }; CONFERENCE_START: { actions: string[]; target: TaskState; }; }; }

on: { CONFERENCE_FAILED: { actions: string[]; target: TaskState; }; CONFERENCE_START: { actions: string[]; target: TaskState; }; }

CONFERENCE_FAILED: { actions: string[]; target: TaskState; }

actions: string[]

target: TaskState

CONFERENCE_START: { actions: string[]; target: TaskState; }

actions: string[]

target: TaskState

ASSIGN: { actions: string[]; target: TaskState; }

Class Task`Abstract`

accept: Res<AgentContact, {
interactionId: string;
}>

blindTransfer: Res<AgentContact, {
data: TransferPayLoad;
interactionId: string;
}>

cancelCtq: Res<AgentContact, {
data: cancelCtq;
interactionId: string;
}>

cancelTask: Res<AgentContact, {
interactionId: string;
}>

conferenceTransfer: Res<AgentContact, {
interactionId: string;
}>

consult: Res<AgentContact, {
data: ConsultPayload;
interactionId: string;
}>

consultAccept: Res<AgentContact, {
interactionId: string;
}>

consultConference: Res<AgentContact, {
data: ConsultConferenceData;
interactionId: string;
}>

consultEnd: Res<AgentContact, {
data: ConsultEndPayload;
interactionId: string;
}>

consultTransfer: Res<AgentContact, {
data: ConsultTransferPayLoad;
interactionId: string;
}>

end: Res<AgentContact, {
interactionId: string;
}>

exitConference: Res<AgentContact, {
interactionId: string;
}>

hold: Res<AgentContact, {
data: HoldResumePayload;
interactionId: string;
}>

pauseRecording: Res<AgentContact, {
interactionId: string;
}>

resumeRecording: Res<AgentContact, {
data: ResumeRecordingPayload;
interactionId: string;
}>

unHold: Res<AgentContact, {
data: HoldResumePayload;
interactionId: string;
}>

vteamTransfer: Res<AgentContact, {
data: TransferPayLoad;
interactionId: string;
}>

wrapup: Res<AgentContact, {
data: WrapupPayLoad;
interactionId: string;
}>

`Optional` autoWrapup

`Optional` state

on: {
CONTACT_OWNER_CHANGED: {
actions: string[];
};
CONTACT_UPDATED: {
actions: string[];
};
HYDRATE: {
actions: string[];
};
RECORDING_STARTED: {
actions: string[];
};
}

CONTACT_OWNER_CHANGED: {
actions: string[];
}

CONTACT_UPDATED: {
actions: string[];
}

HYDRATE: {
actions: string[];
}

RECORDING_STARTED: {
actions: string[];
}

COMPLETED: {
entry: string[];
type: "final";
}

CONFERENCE_END: ({
actions: string[];
guard: ((namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard: ((namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target: TaskState;
})[]

CONFERENCE_START: {
actions: string[];
}

CONSULT: {
actions: string[];
target: TaskState;
}

CONSULT_END: {
actions: string[];
}

CONTACT_ENDED: {
actions: string[];
}[]

EXIT_CONFERENCE_SUCCESS: ({
actions: string[];
guard: ((__namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target: TaskState;
})[]

HOLD_SUCCESS: {
actions: string[];
}

PARTICIPANT_LEAVE: ({
actions: string[];
guard: ((params) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target?: undefined;
})[]

TRANSFER_CONFERENCE: {
actions: string[];
}

TRANSFER_CONFERENCE_FAILED: {
actions: string[];
}

TRANSFER_CONFERENCE_SUCCESS: {
actions: string[];
guard: ((__namedParameters) => boolean);
}[]

UNHOLD_SUCCESS: {
actions: string[];
}

CONF_INITIATING: {
on: {
CONFERENCE_FAILED: {
actions: string[];
target: TaskState;
};
CONFERENCE_START: {
actions: string[];
target: TaskState;
};
};
}

on: {
CONFERENCE_FAILED: {
actions: string[];
target: TaskState;
};
CONFERENCE_START: {
actions: string[];
target: TaskState;
};
}

CONFERENCE_FAILED: {
actions: string[];
target: TaskState;
}

CONFERENCE_START: {
actions: string[];
target: TaskState;
}

ASSIGN: {
actions: string[];
target: TaskState;
}

CONSULT: {
actions: string[];
target: TaskState;
}

CONSULTING_ACTIVE: {
actions: string[];
target: TaskState;
}

CONTACT_ENDED: ({
actions: string[];
guard: ((__namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target: TaskState;
})[]

HOLD_INITIATED: {
target: TaskState;
}

HOLD_SUCCESS: {
actions: string[];
target: TaskState;
}

PAUSE_RECORDING: {
actions: string[];
}

RESUME_RECORDING: {
actions: string[];
}

TASK_WRAPUP: {
actions: string[];
target: TaskState;
}

TRANSFER_FAILED: {
actions: string[];
}

TRANSFER_SUCCESS: ({
actions: string[];
guard: ((__namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target?: undefined;
})[]

ASSIGN: {
actions: string[];
target: TaskState;
}

CONFERENCE_START: {
actions: string[];
target: TaskState;
}

CONSULTING_ACTIVE: {
actions: string[];
}

CONSULT_END: ({
actions: string[];
guard: ((__namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target: TaskState;
})[]

CONTACT_ENDED: {
actions: string[];
target: TaskState;
}

HOLD_SUCCESS: {
actions: string[];
}

MERGE_TO_CONFERENCE: {
target: TaskState;
}

SWITCH_TO_CONSULT: {
actions: string[];
}

SWITCH_TO_MAIN_CALL: {
actions: string[];
}

TASK_WRAPUP: {
actions: string[];
target: TaskState;
}

TRANSFER_CONFERENCE: {
actions: string[];
}

TRANSFER_CONFERENCE_FAILED: {
actions: string[];
}

TRANSFER_CONFERENCE_SUCCESS: ({
actions: string[];
guard: ((namedParameters) => boolean);
target?: undefined;
} | {
actions: string[];
guard: ((namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target: TaskState;
})[]

TRANSFER_FAILED: {
actions: string[];
}

TRANSFER_SUCCESS: ({
actions: string[];
guard: ((__namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target: TaskState;
})[]

UNHOLD_SUCCESS: {
actions: string[];
}

CONSULT_FAILED: ({
actions: string[];
guard: ((__namedParameters) => boolean);
target: TaskState;
} | {
actions: string[];
guard?: undefined;
target: TaskState;
})[]

CONSULT_SUCCESS: {
actions: string[];
target: TaskState;
}