twilio-taskrouter 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+0.8.3
+==========
+Maintenance
+----------
+- Increased timeout for http requests from 5s to 15s
+
 0.8.2
 ==========
 Bug Fixes

package/dist/declarations/Activity.d.ts

@@ -0,0 +1,17 @@
+export const ActivityProperties: string[];
+export default Activity;
+export type ActivityUpdateOptions = {
+    rejectPendingReservations?: boolean | undefined;
+};
+declare interface Activity {
+    readonly accountSid: string;
+    readonly available: boolean;
+    readonly dateCreated: Date;
+    readonly dateUpdated: Date;
+    readonly name: string;
+    readonly sid: string;
+    readonly workspaceSid: string;
+    get isCurrent(): boolean;
+    setAsCurrent(options?: ActivityUpdateOptions | undefined): Promise<Activity>;
+}
+import ActivityDescriptor from "./descriptors/ActivityDescriptor";

package/dist/declarations/Channel.d.ts

@@ -0,0 +1,19 @@
+export const ChannelProperties: string[];
+export default Channel;
+declare interface Channel extends EventEmitter {
+    readonly accountSid: string;
+    readonly assignedTasks: number;
+    readonly available: boolean;
+    readonly availableCapacityPercentage: number;
+    readonly capacity: number;
+    readonly dateCreated: Date;
+    readonly dateUpdated: Date;
+    readonly lastReservedTime: Date;
+    readonly sid: string;
+    readonly taskChannelSid: string;
+    readonly taskChannelUniqueName: string;
+    readonly workerSid: string;
+    readonly workspaceSid: string;
+}
+import { EventEmitter } from "events";
+import WorkerChannelDescriptor from "./descriptors/WorkerChannelDescriptor";

package/dist/declarations/Reservation.d.ts

@@ -0,0 +1,89 @@
+export const ReservationProperties: string[];
+export default Reservation;
+export type RejectOptions = {
+    activitySid: string;
+};
+export type CallOptions = {
+    accept?: boolean | undefined;
+    record?: string | undefined;
+    statusCallbackUrl?: string | undefined;
+    to?: string | undefined;
+    timeout?: number | undefined;
+};
+export type DequeueOptions = {
+    from?: string | undefined;
+    to?: string | undefined;
+    postWorkActivitySid?: string | undefined;
+    record?: string | undefined;
+    timeout?: number | undefined;
+    statusCallbackUrl?: string | undefined;
+    statusCallbackEvents?: string | undefined;
+};
+export type RedirectOptions = {
+    accept?: boolean | undefined;
+};
+export type ConferenceOptions = {
+    to?: string | undefined;
+    from?: string | undefined;
+    timeout?: number | undefined;
+    statusCallback?: string | undefined;
+    statusCallbackMethod?: string | undefined;
+    statusCallbackEvent?: string | undefined;
+    record?: string | undefined;
+    muted?: boolean | undefined;
+    beep?: string | boolean | undefined;
+    startConferenceOnEnter?: boolean | undefined;
+    endConferenceOnExit?: boolean | undefined;
+    endConferenceOnCustomerExit?: boolean | undefined;
+    beepOnCustomerEntrance?: boolean | undefined;
+    waitUrl?: string | undefined;
+    waitMethod?: string | undefined;
+    earlyMedia?: boolean | undefined;
+    maxParticipants?: number | undefined;
+    conferenceStatusCallback?: string | undefined;
+    conferenceStatusCallbackMethod?: string | undefined;
+    conferenceStatusCallbackEvent?: string | undefined;
+    conferenceRecord?: string | boolean | undefined;
+    conferenceTrim?: string | undefined;
+    recordingChannels?: string | undefined;
+    recordingStatusCallback?: string | undefined;
+    recordingStatusCallbackMethod?: string | undefined;
+    conferenceRecordingStatusCallback?: string | undefined;
+    conferenceRecordingStatusCallbackMethod?: string | undefined;
+    region?: string | undefined;
+    sipAuthUsername?: string | undefined;
+    sipAuthPassword?: string | undefined;
+};
+export type ReservationParticipantOptions = {
+    endConferenceOnExit: boolean;
+    mute: boolean;
+    beepOnExit: boolean;
+};
+declare interface Reservation extends EventEmitter {
+    readonly task: Task | {};
+    readonly transfer: IncomingTransfer | {};
+    readonly accountSid: string;
+    readonly dateCreated: Date;
+    readonly dateUpdated: Date;
+    readonly sid: string;
+    readonly status: "pending" | "accepted" | "rejected" | "timeout" | "canceled" | "rescinded" | "wrapping" | "completed";
+    readonly timeout: number;
+    readonly workerSid: string;
+    readonly workspaceSid: string;
+    readonly version: string;
+    readonly canceledReasonCode: number | undefined;
+    accept(): Promise<Reservation>;
+    complete(): Promise<Reservation>;
+    reject(options?: RejectOptions | undefined): Promise<Reservation>;
+    wrap(): Promise<Reservation>;
+    call(from: string, url: string, options?: CallOptions | undefined): Promise<Reservation>;
+    dequeue(options?: DequeueOptions | undefined): Promise<Reservation>;
+    redirect(callSid: string, url: string, options?: RedirectOptions | undefined): Promise<Reservation>;
+    conference(options?: ConferenceOptions | undefined): Promise<Reservation>;
+    updateParticipant(options: ReservationParticipantOptions): Promise<Reservation>;
+    fetchLatestVersion(): Promise<Reservation>;
+}
+import { EventEmitter } from "events";
+import Task from "./Task";
+import IncomingTransfer from "./core/transfer/IncomingTransfer";
+import ReservationDescriptor from "./descriptors/ReservationDescriptor";

package/dist/declarations/Supervisor.d.ts

@@ -0,0 +1,7 @@
+export const SuperviseModes: string[];
+export default Supervisor;
+declare class Supervisor extends Worker {
+    monitor(taskSid: string, reservationSid: string, extraParams?: Record<any, any> | undefined): Promise<void>;
+    private _supervise;
+}
+import Worker from "./Worker";

package/dist/declarations/Task.d.ts

@@ -0,0 +1,53 @@
+export const TaskProperties: string[];
+export default Task;
+export type TransferOptions = {
+    attributes: Record<any, any>;
+    mode: 'WARM' | 'COLD';
+    priority: number;
+};
+export type WrappingOptions = {
+    reason: string;
+};
+export type TaskParticipantOptions = {
+    hold: boolean;
+    holdUrl: string;
+    holdMethod: 'GET';
+};
+export type HoldOptions = {
+    holdUrl: string;
+    holdMethod: 'GET';
+};
+declare interface Task extends EventEmitter {
+    readonly transfers: Transfers;
+    readonly addOns: Record<any, any>;
+    readonly age: number;
+    readonly attributes: Record<any, any>;
+    readonly dateCreated: Date;
+    readonly dateUpdated: Date;
+    readonly priority: number;
+    readonly queueName: string;
+    readonly queueSid: string;
+    readonly reason: string;
+    readonly routingTarget: string;
+    readonly sid: string;
+    readonly status: 'pending' | 'reserved' | 'assigned' | 'canceled' | 'completed' | 'wrapping';
+    readonly taskChannelUniqueName: string;
+    readonly taskChannelSid: string;
+    readonly timeout: number;
+    readonly workflowName: string;
+    readonly workflowSid: string;
+    readonly version: string;
+    readonly reservationSid: string;
+    complete(reason: string): Promise<Task>;
+    transfer(to: string, options?: TransferOptions | undefined): Promise<Task>;
+    wrapUp(options?: WrappingOptions): Promise<Task>;
+    setAttributes(attributes: Record<any, any>): Promise<Task>;
+    updateParticipant(options: TaskParticipantOptions): Promise<Task>;
+    kick(workerSid: string): Promise<Task>;
+    hold(targetWorkerSid: string, onHold: boolean, options: HoldOptions): Promise<Task>;
+    fetchLatestVersion(): Promise<Task>;
+}
+import { EventEmitter } from "events";
+import Transfers from "./core/transfer/Transfers";
+import Worker from "./Worker";
+import TaskDescriptor from "./descriptors/TaskDescriptor";

package/dist/declarations/TaskQueue.d.ts

@@ -0,0 +1,20 @@
+export const TaskQueueProperties: string[];
+export default TaskQueue;
+declare interface TaskQueue {
+    readonly sid: string;
+    readonly queueSid: string;
+    readonly accountSid: string;
+    readonly workspaceSid: string;
+    readonly name: string;
+    readonly queueName: string;
+    readonly assignmentActivityName: string;
+    readonly reservationActivityName: string;
+    readonly assignmentActivitySid: string;
+    readonly reservationActivitySid: string;
+    readonly targetWorkers: string;
+    readonly maxReservedWorkers: number;
+    readonly taskOrder: string;
+    readonly dateCreated: Date;
+    readonly dateUpdated: Date;
+}
+import TaskQueueDescriptor from "./descriptors/TaskQueueDescriptor";

package/dist/declarations/Worker.d.ts

@@ -0,0 +1,70 @@
+export const WorkerProperties: string[];
+export default Worker;
+export type WorkerOptions = {
+    connectActivitySid?: string | undefined;
+    closeExistingSessions?: boolean | undefined;
+    logLevel?: string | undefined;
+    region?: string | undefined;
+};
+export type WorkerDeps = {
+    Request: Request;
+    EventBridgeSignaling: EventBridgeSignaling;
+};
+export type WorkerTaskOptions = {
+    attributes?: Record<any, any> | undefined;
+    taskChannelUniqueName?: string | undefined;
+    taskChannelSid?: string | undefined;
+};
+declare class Worker extends EventEmitter {
+    constructor(token: string, options?: WorkerOptions | undefined, deps?: WorkerDeps | undefined);
+    private _connectActivitySid;
+    private _closeExistingSessions;
+    private _logLevel;
+    private _config;
+    private _log;
+    private _request;
+    private _dataServices;
+    private _routes;
+    private _connectRetry;
+    private _signaling;
+    private retryUtil;
+    private taskRouterEventHandler;
+    readonly activity: typeof import("./Activity");
+    readonly accountSid: string;
+    readonly attributes: Record<any, any>;
+    readonly dateCreated: Date;
+    readonly dateStatusChanged: Date;
+    readonly dateUpdated: Date;
+    readonly name: string;
+    readonly sid: string;
+    readonly workspaceSid: string;
+    version: string;
+    readonly workerSid: string;
+    readonly workerActivitySid: string;
+    readonly friendlyName: string;
+    readonly dateActivityChanged: Date;
+    createTask(to: string, from: string, workflowSid: string, taskQueueSid: string, options?: WorkerTaskOptions | undefined): Promise<string>;
+    getLogger(prefix: string): Logger;
+    setAttributes(attributes: Record<any, any>): Promise<Worker>;
+    _bumpVersion(): void;
+    updateToken(newToken: string): void;
+    fetchLatestVersion(): Promise<Worker>;
+    private _subscribeToSignalingEvents;
+    private _subscribeToTaskRouterEvents;
+    private _unSubscribeFromTaskRouterEvents;
+    private _initialize;
+    get channels(): Map<string, typeof import("./Channel")>;
+    get activities(): Map<string, typeof import("./Activity")>;
+    get reservations(): Map<string, typeof import("./Reservation")>;
+    private _setCurrentActivity;
+    private _setWorkerConnectActivity;
+    private _updateWorkerActivity;
+    private _update;
+    disconnect(): void;
+    getRoutes(): Routes;
+}
+import Request from "./util/Request";
+import EventBridgeSignaling from "./signaling/EventBridgeSignaling";
+import { EventEmitter } from "events";
+import Logger from "./util/Logger";
+import Routes from "./util/Routes";

package/dist/declarations/WorkerContainer.d.ts

@@ -0,0 +1,5 @@
+export default WorkerContainer;
+declare class WorkerContainer {
+    constructor(descriptor: WorkerDescriptor);
+}
+import WorkerDescriptor from "./descriptors/WorkerDescriptor";

package/dist/declarations/Workspace.d.ts

@@ -0,0 +1,40 @@
+export default Workspace;
+export type WorkspaceOptions = {
+    region?: string | undefined;
+    pageSize?: number | undefined;
+    logLevel?: string | undefined;
+};
+export type FetchWorkersParams = {
+    AfterSid?: string | undefined;
+    FriendlyName?: string | undefined;
+    ActivitySid?: string | undefined;
+    ActivityName?: string | undefined;
+    TargetWorkersExpression?: string | undefined;
+    Ordering?: "DateStatusChanged:asc" | "DateStatusChanged:desc" | undefined;
+    MaxWorkers?: number | undefined;
+};
+export type FetchTaskQueuesParams = {
+    AfterSid?: string | undefined;
+    FriendlyName?: string | undefined;
+    Ordering?: "DateUpdated:asc" | "DateUpdated:desc" | undefined;
+};
+declare class Workspace {
+    constructor(jwt: string, options?: WorkspaceOptions | undefined, workspaceSid?: string | undefined);
+    private _config;
+    private _request;
+    private _logLevel;
+    private _log;
+    private shouldDecodeToken;
+    readonly workspaceSid: string;
+    private workspaceEntity;
+    fetchWorker(workerSid: string): Promise<typeof import("./Worker")>;
+    fetchWorkers(params?: FetchWorkersParams | undefined): Promise<Map<string, typeof import("./Worker")>>;
+    fetchTaskQueue(queueSid: string): Promise<typeof import("./TaskQueue")>;
+    fetchTaskQueues(params?: FetchTaskQueuesParams | undefined): Promise<Map<string, typeof import("./TaskQueue")>>;
+    updateToken(newToken: string): void;
+    private _updateJWTProperties;
+    private jwt;
+    private accountSid;
+    private workerSid;
+    private role;
+}

package/dist/declarations/core/transfer/IncomingTransfer.d.ts

@@ -0,0 +1,5 @@
+export default IncomingTransfer;
+declare class IncomingTransfer extends Transfer {
+    constructor(worker: typeof import("../../Worker"), descriptor: typeof import("../../descriptors/TransferDescriptor"));
+}
+import Transfer from "./Transfer";

package/dist/declarations/core/transfer/OutgoingTransfer.d.ts

@@ -0,0 +1,10 @@
+export default OutgoingTransfer;
+declare class OutgoingTransfer extends Transfer {
+    constructor(worker: typeof import("../../Worker"), request: typeof import("../../util/Request"), taskSid: string, descriptor: typeof import("../../descriptors/TransferDescriptor"));
+    private _worker;
+    private _request;
+    taskSid: string;
+    private _emitEvent;
+    public cancel(): Promise<OutgoingTransfer>;
+}
+import Transfer from "./Transfer";

package/dist/declarations/core/transfer/Transfer.d.ts

@@ -0,0 +1,21 @@
+export const TransferProperties: string[];
+export default Transfer;
+declare class Transfer extends EventEmitter {
+    constructor(worker: typeof import("../../Worker"), descriptor: TransferDescriptor);
+    private _log;
+    dateCreated: Date;
+    dateUpdated: Date;
+    mode: string;
+    queueSid: string;
+    reservationSid: string;
+    to: string;
+    transferFailedReason: string | null;
+    type: string;
+    sid: string;
+    status: string;
+    workerSid: string;
+    workflowSid: string;
+    _update(latestTransferData: Object): this;
+}
+import { EventEmitter } from "events";
+import TransferDescriptor from "../../descriptors/TransferDescriptor";

package/dist/declarations/core/transfer/Transfers.d.ts

@@ -0,0 +1,16 @@
+export default Transfers;
+declare class Transfers extends EventEmitter {
+    constructor(worker: typeof import("../../Worker"), request: typeof import("../../util/Request"), taskDescriptor: TaskDescriptor);
+    private _log;
+    private _worker;
+    private _request;
+    incoming: IncomingTransfer;
+    outgoing: OutgoingTransfer;
+    _emitEvent(eventType: Object, rawEventData: Object): void;
+    private _updateOutgoing;
+    _update(latestTransfersData: Object): void;
+}
+import { EventEmitter } from "events";
+import IncomingTransfer from "./IncomingTransfer";
+import OutgoingTransfer from "./OutgoingTransfer";
+import TaskDescriptor from "../../descriptors/TaskDescriptor";

package/dist/declarations/data/ActivitiesEntity.d.ts

@@ -0,0 +1,19 @@
+export default class ActivitiesEntity {
+    constructor(worker: typeof import("../Worker"), request: typeof import("../util/Request"), options?: Activities.Options | undefined);
+    private _activities;
+    private _log;
+    private _request;
+    private _worker;
+    private _pageSize;
+    get activities(): Map<string, Activity>;
+    public fetchActivities(): Promise<Map<string, Activity>>;
+    private _getAllActivities;
+    private _getPage;
+    private _insertActivity;
+}
+export namespace Activities {
+    type Options = {
+        pageSize?: number | undefined;
+    };
+}
+import Activity from "../Activity";

package/dist/declarations/data/ChannelsEntity.d.ts

@@ -0,0 +1,20 @@
+export default class ChannelsEntity {
+    constructor(worker: Worker, request: typeof import("../util/Request"), options?: Channels.Options | undefined);
+    private _channels;
+    private _log;
+    private _request;
+    private _pageSize;
+    private _worker;
+    get channels(): Map<string, Channel>;
+    public fetchChannels(): Promise<Map<string, Channel>>;
+    private _getAllChannels;
+    private _getPage;
+    private _insertChannel;
+}
+export namespace Channels {
+    type Options = {
+        pageSize?: number | undefined;
+    };
+}
+import Channel from "../Channel";
+import Worker from "../Worker";

package/dist/declarations/data/ReservationsEntity.d.ts

@@ -0,0 +1,26 @@
+export default class ReservationsEntity extends EventEmitter {
+    constructor(worker: Worker, request: typeof import("../util/Request"), options?: Reservations.Options | undefined);
+    private _worker;
+    private _log;
+    private _request;
+    private _reservations;
+    private _reservationSidsByTask;
+    private _pageSize;
+    get reservations(): Map<string, Reservation>;
+    public fetchReservations(): Promise<Map<string, Reservation>>;
+    private _getAllReservations;
+    private _getPage;
+    private _insertReservation;
+    public insert(rawReservationData: Object): Reservation;
+    public getTasks(taskSid: string): [typeof import("../Task")] | null;
+    private _deleteByReservationSid;
+    private _cleanUpReservationAndTask;
+}
+export namespace Reservations {
+    type Options = {
+        pageSize?: number | undefined;
+    };
+}
+import { EventEmitter } from "events";
+import Reservation from "../Reservation";
+import Worker from "../Worker";

package/dist/declarations/data/WorkspaceEntity.d.ts

@@ -0,0 +1,22 @@
+export default class WorkspaceEntity {
+    constructor(workspaceSid: string, request: typeof import("../util/Request"), options?: import('Workspace').WorkspaceOptions | undefined);
+    private _Workers;
+    private _TaskQueues;
+    private _routes;
+    private _request;
+    private _log;
+    private _pageSize;
+    get Workers(): Map<string, Worker>;
+    get TaskQueues(): Map<string, TaskQueue>;
+    public fetchWorker(workerSid: string): Promise<Worker>;
+    public fetchWorkers(params: import('Workspace').FetchWorkersParams): Promise<Map<string, Worker>>;
+    public fetchTaskQueue(queueSid: string): Promise<TaskQueue>;
+    public fetchTaskQueues(params: import('Workspace').FetchTaskQueuesParams): Promise<Map<string, TaskQueue>>;
+    private _getAllWorkers;
+    private _getWorkerPage;
+    private _insertWorker;
+    private _getAllTaskQueues;
+    private _getTaskQueuePage;
+    private _insertTaskQueue;
+}
+import TaskQueue from "../TaskQueue";

package/dist/declarations/descriptors/ActivityDescriptor.d.ts

@@ -0,0 +1,10 @@
+export default class ActivityDescriptor {
+    constructor(descriptor: Object);
+    accountSid: string;
+    available: boolean;
+    dateCreated: Date;
+    dateUpdated: Date;
+    name: string;
+    sid: string;
+    workspaceSid: string;
+}

package/dist/declarations/descriptors/ReservationDescriptor.d.ts

@@ -0,0 +1,17 @@
+export default class ReservationDescriptor {
+    constructor(descriptor: Object, worker: typeof import("../Worker"), ignoredProperties?: Array<string>);
+    accountSid: string;
+    dateCreated: Date;
+    dateUpdated: Date;
+    sid: string;
+    status: string;
+    timeout: number;
+    workerSid: string;
+    workspaceSid: string;
+    taskDescriptor: TaskDescriptor | null;
+    transferDescriptor: TransferDescriptor | null;
+    version: string;
+    canceledReasonCode: number | null;
+}
+import TaskDescriptor from "./TaskDescriptor";
+import TransferDescriptor from "./TransferDescriptor";

package/dist/declarations/descriptors/TaskDescriptor.d.ts

@@ -0,0 +1,23 @@
+export default class TaskDescriptor {
+    constructor(descriptor: Object);
+    addOns: Object;
+    age: number;
+    attributes: Object;
+    dateCreated: Date;
+    dateUpdated: Date;
+    priority: number;
+    queueName: string;
+    queueSid: string;
+    reason: string;
+    routingTarget: string;
+    sid: string;
+    status: string;
+    taskChannelUniqueName: string;
+    taskChannelSid: string;
+    timeout: number;
+    workflowName: string;
+    workflowSid: string;
+    incomingTransferDescriptor: typeof import("./TransferDescriptor") | null;
+    outgoingTransferDescriptor: typeof import("./TransferDescriptor") | null;
+    version: string;
+}

package/dist/declarations/descriptors/TaskQueueDescriptor.d.ts

@@ -0,0 +1,18 @@
+export default class TaskQueueDescriptor {
+    constructor(descriptor: Object);
+    sid: string;
+    queueSid: string;
+    accountSid: string;
+    workspaceSid: string;
+    name: string;
+    queueName: string;
+    assignmentActivityName: string;
+    reservationActivityName: string;
+    assignmentActivitySid: string;
+    reservationActivitySid: string;
+    targetWorkers: string;
+    maxReservedWorkers: number;
+    taskOrder: string;
+    dateCreated: Date;
+    dateUpdated: Date;
+}

package/dist/declarations/descriptors/TransferDescriptor.d.ts

@@ -0,0 +1,15 @@
+export default class TransferDescriptor {
+    constructor(descriptor: Object);
+    dateCreated: Date;
+    dateUpdated: Date;
+    mode: string;
+    queueSid: string;
+    reservationSid: string;
+    to: string;
+    transferFailedReason: string | null;
+    type: string;
+    sid: string;
+    status: string;
+    workerSid: string;
+    workflowSid: string;
+}

package/dist/declarations/descriptors/WorkerChannelDescriptor.d.ts

@@ -0,0 +1,16 @@
+export default class WorkerChannelDescriptor {
+    constructor(descriptor: Object);
+    accountSid: string;
+    assignedTasks: number;
+    available: boolean;
+    availableCapacityPercentage: number;
+    capacity: number;
+    dateCreated: Date;
+    dateUpdated: Date;
+    lastReservedTime: Date;
+    sid: string;
+    taskChannelSid: string;
+    taskChannelUniqueName: string;
+    workerSid: string;
+    workspaceSid: string;
+}

package/dist/declarations/descriptors/WorkerDescriptor.d.ts

@@ -0,0 +1,19 @@
+export default class WorkerDescriptor {
+    constructor(descriptor: Object);
+    accountSid: string;
+    activityName: string;
+    activitySid: string;
+    attributes: Object;
+    available: boolean;
+    dateCreated: Date;
+    dateStatusChanged: Date;
+    dateUpdated: Date;
+    name: string;
+    sid: string;
+    workspaceSid: string;
+    version: string;
+    workerSid: string;
+    workerActivitySid: string;
+    dateActivityChanged: Date;
+    friendlyName: string;
+}

package/dist/declarations/handlers/TaskRouterEventHandler.d.ts

@@ -0,0 +1,40 @@
+export default class TaskRouterEventHandler {
+    constructor(worker: typeof import("../Worker"), options?: Object | undefined);
+    private _worker;
+    private _logLevel;
+    private _log;
+    public getTREventsToHandlerMapping(): {
+        "task.transfer-completed": string;
+        "reservation.completed": string;
+        "task.transfer-attempt-failed": string;
+        "reservation.created": string;
+        "task.updated": string;
+        "reservation.rescinded": string;
+        "worker.attributes.update": string;
+        "worker.channel.availability.update": string;
+        "task.transfer-initiated": string;
+        "reservation.accepted": string;
+        "reservation.timeout": string;
+        "reservation.failed": string;
+        "worker.activity.update": string;
+        "reservation.rejected": string;
+        "task.canceled": string;
+        "task.transfer-failed": string;
+        "task.wrapup": string;
+        "reservation.wrapup": string;
+        "reservation.canceled": string;
+        "task.transfer-canceled": string;
+        "worker.capacity.update": string;
+        "task.completed": string;
+    };
+    private _workerActivityUpdateHandler;
+    private _workerAttributesUpdateHandler;
+    private _workerCapacityUpdateHandler;
+    private _workerChannelAvailabilityUpdateHandler;
+    private _reservationCreatedHandler;
+    private _reservationFailedHandler;
+    private _reservationUpdateHandler;
+    private _reservationCleanupEventsHandler;
+    private _taskTypeEventHandler;
+    private _transferTaskEventHandler;
+}