twilio-taskrouter 0.8.2 → 0.8.3

package/dist/declarations/index.d.ts

@@ -0,0 +1,27 @@
+export as namespace TaskRouter;
+
+import Activity from './Activity';
+import Channel from './Channel';
+import Reservation from './Reservation';
+import Task from './Task';
+import TaskQueue from './TaskQueue';
+
+// exporting all types
+export * from './Activity';
+export * from './Channel';
+export * from './Reservation';
+export * from './Task';
+export * from './TaskQueue';
+export * from './Supervisor';
+export * from './Worker';
+export * from './Workspace';
+export * from './handlers/TaskRouterEventHandler';
+
+// named exports for interfaces
+export { Activity, Channel, Reservation, Task, TaskQueue };
+
+// Default exports
+export { default as Supervisor } from './Supervisor';
+export { default as Worker } from './Worker';
+export { default as Workspace } from './Workspace';
+export { default as TaskRouterEventHandler } from './handlers/TaskRouterEventHandler';

package/dist/declarations/signaling/EventBridgeSignaling.d.ts

@@ -0,0 +1,26 @@
+export default class EventBridgeSignaling extends EventEmitter {
+    constructor(worker: typeof import("../Worker"), options?: EventBridgeSignal.Options | undefined);
+    private _heartbeat;
+    private webSocket;
+    private _log;
+    private _worker;
+    closeExistingSessions: boolean;
+    private _config;
+    private reconnect;
+    private tokenTimer;
+    public updateToken(newToken: string): void;
+    private setTokenExpirationEvent;
+    private setUpWebSocket;
+    public setLifetime(lifetime: number): void;
+    tokenLifetime: number | undefined;
+    private createWebSocket;
+    private numAttempts;
+    private generateBackOffInterval;
+    public disconnect(): void;
+}
+export namespace EventBridgeSignal {
+    type Options = {
+        closeExistingSessions?: boolean | undefined;
+    };
+}
+import { EventEmitter } from "events";

package/dist/declarations/util/BaseRoutes.d.ts

@@ -0,0 +1,4 @@
+export default class BaseRoutes {
+    routes: Object;
+    public getRoute(route: string, ...args: any[]): keyof BaseRoutes;
+}

package/dist/declarations/util/Configuration.d.ts

@@ -0,0 +1,22 @@
+export default class Configuration {
+    constructor(token: string, options?: Configuration.Options | undefined);
+    logIdentifier: string;
+    private _logLevel;
+    private _log;
+    token: string;
+    EB_SERVER: string;
+    WS_SERVER: string;
+    public updateToken(newToken: string): void;
+    public getLogIdentifier(): string;
+}
+export namespace Configuration {
+    type Options = {
+        region?: string | undefined;
+        ebServer?: string | undefined;
+        wsServer?: string | undefined;
+        logIdentifier?: string | undefined;
+        connectActivitySid?: string | undefined;
+        closeExistingSessions?: boolean | undefined;
+        logLevel?: string | undefined;
+    };
+}

package/dist/declarations/util/Constants.d.ts

@@ -0,0 +1,106 @@
+export const RESERVATION_STATUS_ACCEPTED: "accepted";
+export const RESERVATION_STATUS_COMPLETED: "completed";
+export const RESERVATION_STATUS_REJECTED: "rejected";
+export const RESERVATION_STATUS_WRAPPING: "wrapping";
+export const RESERVATION_INSTRUCTION_CALL: "call";
+export const RESERVATION_INSTRUCTION_DEQUEUE: "dequeue";
+export const RESERVATION_INSTRUCTION_REDIRECT: "redirect";
+export const RESERVATION_INSTRUCTION_CONFERENCE: "conference";
+export const TRANSFER_STATUS: Readonly<{
+    canceled: "canceled";
+    complete: "complete";
+    failed: "failed";
+    initiated: "initiated";
+}>;
+export namespace RESERVATION_REJECT_OPTIONS {
+    const activitySid: string;
+}
+export namespace WORKER_UPDATE_OPTIONS {
+    const rejectPendingReservations: string;
+}
+export namespace RESERVATION_CALL_OPTIONS {
+    const accept: string;
+    const record: string;
+    const statusCallbackUrl: string;
+    const timeout: string;
+    const to: string;
+}
+export namespace RESERVATION_DEQUEUE_OPTIONS {
+    const to_1: string;
+    export { to_1 as to };
+    export const from: string;
+    export const postWorkActivitySid: string;
+    const record_1: string;
+    export { record_1 as record };
+    const timeout_1: string;
+    export { timeout_1 as timeout };
+    const statusCallbackUrl_1: string;
+    export { statusCallbackUrl_1 as statusCallbackUrl };
+    export const statusCallbackEvents: string;
+}
+export namespace RESERVATION_REDIRECT_OPTIONS {
+    const accept_1: string;
+    export { accept_1 as accept };
+}
+export namespace CREATE_TASK_OPTIONS {
+    const taskChannelUniqueName: string;
+    const taskChannelSid: string;
+    const attributes: string;
+}
+export const TASK_STATUS_COMPLETED: "completed";
+export const TASK_STATUS_WRAPPING: "wrapping";
+export namespace reservationEventTypes {
+    export const accepted: number;
+    export const rejected: number;
+    const timeout_2: number;
+    export { timeout_2 as timeout };
+    export const canceled: number;
+    export const rescinded: number;
+    export const completed: number;
+    export const wrapup: number;
+}
+export const taskEventTypes: {
+    'task.updated': string;
+    'task.canceled': string;
+    'task.completed': string;
+    'task.wrapup': string;
+};
+export const reservationToSDKEventsMapping: {
+    'reservation.completed': string;
+    'reservation.rejected': string;
+    'reservation.timeout': string;
+    'reservation.canceled': string;
+    'reservation.rescinded': string;
+    'reservation.accepted': string;
+    'reservation.wrapup': string;
+};
+export const transferFields: Readonly<{
+    taskTransfer: "task_transfer";
+    activeOutgoingTaskTransfer: "active_outgoing_task_transfer";
+}>;
+export const TRANSFER_INITIATED: "transfer-initiated";
+export const taskTransferEventTypes: {
+    'transfer-attempt-failed': string;
+    'transfer-completed': string;
+    'transfer-failed': string;
+    'transfer-initiated': string;
+    'transfer-canceled': string;
+};
+export const taskTransferEventEmitterMapping: {
+    'task.transfer-attempt-failed': string;
+    'task.transfer-completed': string;
+    'task.transfer-failed': string;
+    'task.transfer-initiated': string;
+    'task.transfer-canceled': string;
+};
+export const API_V1: "v1";
+export const API_V2: "v2";
+export const DEFAULT_PAGE_SIZE: 1000;
+export const DEFAULT_MAX_WORKERS: 1000;
+export const DEFAULT_HTTP_TIMEOUT: 15000;
+export namespace EB_URL_PARAMS {
+    const TOKEN: string;
+    const CLOSE_EXISTING_SESSIONS: string;
+    const CLIENT_VERSION: string;
+}
+export const twilioErrors: {};

package/dist/declarations/util/Heartbeat.d.ts

@@ -0,0 +1,19 @@
+export function Heartbeat(opts: Object): Heartbeat;
+export class Heartbeat {
+    constructor(opts: Object);
+    interval: number;
+    lastbeat: number | undefined;
+    pintvl: any;
+    onsleep: Function;
+    onwakeup: Function;
+    repeat: Function;
+    stop: Function;
+    now: Function;
+    toString(): string;
+    beat(): void;
+    check(): void;
+    sleeping(): boolean;
+}
+export namespace Heartbeat {
+    function toString(): string;
+}

package/dist/declarations/util/Logger.d.ts

@@ -0,0 +1,17 @@
+export default class Logger {
+    constructor(moduleName: string, logLevel: keyof Logger.LogLevel);
+    private _log;
+    setLevel(level: string): void;
+    getLevel(): string;
+    private _getTimestamp;
+}
+export namespace Logger {
+    type LogLevel = {
+        trace: string;
+        debug: string;
+        info: string;
+        warn: string;
+        error: string;
+        silent: string;
+    };
+}

package/dist/declarations/util/Paginator.d.ts

@@ -0,0 +1,8 @@
+export default class Paginator {
+    constructor(items: any[], source: Function, nextToken: boolean);
+    private _nextToken;
+    private _source;
+    hasNextPage: boolean;
+    items: any[];
+    nextPage(): Promise<Paginator>;
+}

package/dist/declarations/util/Request.d.ts

@@ -0,0 +1,8 @@
+export default class Request {
+    constructor(config: Object);
+    private _config;
+    private _postClient;
+    public post(url: string, paramsJSON: Object, apiVersion: string, objectVersion: string): Promise<any>;
+    public get(url: string, apiVersion: string, paramsJSON: Object): Promise<any>;
+    private buildRequest;
+}

package/dist/declarations/util/Retry.d.ts

@@ -0,0 +1,7 @@
+export default class RetryUtil {
+    constructor(baseTimeout?: number | undefined, maxTimeoutLimit?: number | undefined);
+    private _log;
+    public generateBackoffInterval(retryCount: number): number;
+    public whenReady(retryCount: number): Promise<any>;
+    #private;
+}

package/dist/declarations/util/Routes.d.ts

@@ -0,0 +1,67 @@
+export const RESERVATION_LIST: "reservationList";
+export const RESERVATION_INSTANCE: "reservationInstance";
+export const WORKER_INSTANCE: "workerInstance";
+export const TASK_RESERVATION_INSTANCE: "taskReservationInstance";
+export const TASK_LIST: "taskList";
+export const TASK_INSTANCE: "taskInstance";
+export const TASK_TRANSFER_LIST: "taskTransferList";
+export const TASK_TRANSFER_INSTANCE: "taskTransferInstance";
+export const WORKER_CHANNELS: "workerChannels";
+export const ACTIVITIES_LIST: "activitiesList";
+export const CUSTOMER_PARTICIPANT_INSTANCE: "customerParticipantInstance";
+export const WORKER_PARTICIPANT_INSTANCE: "workerParticipantInstance";
+export const HOLD_WORKER_PARTICIPANT_INSTANCE: "holdWorkerParticipantInstance";
+export const KICK_WORKER_PARTICIPANT: "kickWorkerParticipant";
+export default class Routes extends BaseRoutes {
+    constructor(workspaceSid: string, workerSid: string);
+    workspaceSid: string;
+    workerSid: string;
+    routes: Routes.routesTypes;
+}
+export namespace Routes {
+    type routesTypes = {
+        taskTransferInstance: {
+            "path": string;
+        };
+        workerChannels: {
+            "path": string;
+        };
+        workerParticipantInstance: {
+            "path": string;
+        };
+        taskList: {
+            "path": string;
+        };
+        taskTransferList: {
+            "path": string;
+        };
+        kickWorkerParticipant: {
+            "path": string;
+        };
+        workerInstance: {
+            "path": string;
+        };
+        reservationList: {
+            "path": string;
+        };
+        taskReservationInstance: {
+            "path": string;
+        };
+        taskInstance: {
+            "path": string;
+        };
+        reservationInstance: {
+            "path": string;
+        };
+        holdWorkerParticipantInstance: {
+            "path": string;
+        };
+        activitiesList: {
+            "path": string;
+        };
+        customerParticipantInstance: {
+            "path": string;
+        };
+    };
+}
+import BaseRoutes from "./BaseRoutes";

package/dist/declarations/util/Tools.d.ts

@@ -0,0 +1,3 @@
+export function parseTime(timeString: string): null | Date;
+export function validateOptions(options: Object, types: Object): boolean;
+export function getStatusCodeFromError(err: Object | undefined | null): number | undefined | null;

package/dist/declarations/util/TwilioError.d.ts

@@ -0,0 +1,6 @@
+export = TwilioError;
+declare function TwilioError(errorData: Object, customMessage: string): void;
+declare class TwilioError {
+    constructor(errorData: Object, customMessage: string);
+    clone(customMessage: string): TwilioError;
+}

package/dist/declarations/util/WorkspaceRoutes.d.ts

@@ -0,0 +1,18 @@
+export const WORKER_LIST: "workerList";
+export const TASKQUEUE_LIST: "taskQueueList";
+export default class WorkspaceRoutes extends BaseRoutes {
+    constructor(workspaceSid: string);
+    workspaceSid: string;
+    routes: WorkspaceRoutes.routeTypes;
+}
+export namespace WorkspaceRoutes {
+    type routeTypes = {
+        taskQueueList: {
+            "path": string;
+        };
+        workerList: {
+            "path": string;
+        };
+    };
+}
+import BaseRoutes from "./BaseRoutes";

package/dist/declarations/util/errors.d.ts

@@ -0,0 +1,51 @@
+export const ActivityInstantiationError_PayloadRequired: string;
+export const ActivityInstantiationError_WorkerRequired: string;
+export const ActivityEmitEventCallError_PayloadRequired: string;
+export const ActivityEmitEventCallError_EventTypeRequired: string;
+export const ChannelInstantiationError_PayloadRequired: string;
+export const ChannelInstantiationError_ConfigRequired: string;
+export const ChannelSetAvailabilityCallError_IsAvailableRequired: string;
+export const ChannelSetCapacityCallError_CapacityRequired: string;
+export const ChannelEmitEventCallError_EventTypeRequired: string;
+export const ChannelEmitEventCallError_PayloadRequired: string;
+export const ReservationInstantiationError_PayloadRequired: string;
+export const ReservationInstantiationError_ConfigRequired: string;
+export const ReservationCallInstructionError_FromRequired: string;
+export const ReservationCallInstructionError_UrlRequired: string;
+export const ReservationRedirectInstructionError_CallSidRequired: string;
+export const ReservationRedirectInstructionError_UrlRequired: string;
+export const TaskInstantiationError_PayloadRequired: string;
+export const TaskInstantiationError_ConfigRequired: string;
+export const TaskCompletedError_ReasonRequired: string;
+export const WorkerError_InitializationFailed: string;
+export const WorkerInstantiationError_TokenRequired: string;
+export const WorkerFetchTasksError_ReservationStatusRequired: string;
+export const WorkerSetAttributesError_AttributesRequired: string;
+export const WorkerUpdateTokenError_NewTokenRequired: string;
+export const WorkerUpdateActivityError_ActivitySidRequired: string;
+export const EventBridgeSignalingError_WorkerRequired: string;
+export const EventBridgeSignalingError_NewTokenRequired: string;
+export const ConfigurationError_TokenRequired: string;
+export const ConfigurationError_NewTokenRequired: string;
+export const LoggerInstantiationError_ModuleNameRequired: string;
+export const LoggerInstantiationError_InvalidLogLevel: string;
+export const RequestError_BadRequest: string;
+export const RequestJwtError_TokenExpired: string;
+export const RequestJwtError_InvalidTokenOrAccessPolicy: string;
+export const RequestError_InvalidEndpoint: string;
+export const RequestError_InternalError: string;
+export const RequestError_ErrorMakingRequest: string;
+export const GenericUpdatePropertiesError_TargetRequired: string;
+export const GenericUpdatePropertiesError_SourceRequired: string;
+export const GenericUpdatePropertiesError__TypeRequired: string;
+export const GenericJwtError_TokenRequired: string;
+export const GenericJwtError_MalformedToken: string;
+export const GenericJwtError_MissingField: string;
+export const GenericJwtError_GrantMissingRole: string;
+export const DefaultError_InvalidArgument: string;
+export const DefaultError_InvalidToken: string;
+export const DefaultError_TokenExpired: string;
+export const DefaultError_GatewayConnectionFailed: string;
+export const DefaultError_GatewayDisconnected: string;
+export const DefaultError_InvalidGatewayMessage: string;
+export const DefaultError_TaskrouterError: string;