@5minds/processcube_engine_client 4.3.1

package/dist/Clients/Lib/SocketIoManager.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="socket.io-client" />
+import { Identity, Subscription } from '@5minds/processcube_engine_sdk';
+export declare class SocketIoManager {
+    private readonly engineUrl;
+    private socketCollection;
+    private subscriptionCollection;
+    constructor(engineUrl: string);
+    /**
+     * Disconnects the socket associated with the given identity.
+     *
+     * @param identity The identity to disconnect.
+     */
+    disconnectSocket(identity: Identity): void;
+    /**
+     * Disposes all sockets.
+     */
+    dispose(): void;
+    /**
+     * Creates a new socket.io subscription for the given eventName.
+     *
+     * @param identity      The identity for which to create the subscription.
+     * @param eventName     The event to subscribe to.
+     * @param callback      The callback to execute when the event gets triggered.
+     * @param subscribeOnce If true, the subscription will be disposed after the event was received once.
+     */
+    createSocketIoSubscription(identity: Identity, eventName: string, callback: Function, subscribeOnce: boolean): Subscription;
+    /**
+     * Removes the given subscription from the socket associated with the given identity.
+     *
+     * @param identity     The identity for which to remove a subscription.
+     * @param subscription The subscription to remove.
+     */
+    removeSocketIoSubscription(identity: Identity, subscription: Subscription): void;
+    getSocketForIdentity(identity: Identity): SocketIOClient.Socket;
+    private createSocketForIdentity;
+}

package/dist/Clients/ManualTaskHttpClient.d.ts

@@ -0,0 +1,22 @@
+import { DataModels, IManualTaskExtensionAdapter, Identity, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+type ManualTaskList = DataModels.FlowNodeInstances.ManualTaskList;
+export declare class ManualTaskHttpClient extends BaseClient implements IManualTaskExtensionAdapter {
+    query(query: DataModels.FlowNodeInstances.ManualTaskQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.FlowNodeInstances.FlowNodeInstanceSortSettings;
+    }): Promise<ManualTaskList>;
+    finishManualTask(manualTaskInstanceId: string, identity?: Identity): Promise<void>;
+    onManualTaskWaiting(callback: Messages.CallbackTypes.OnManualTaskWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onManualTaskFinished(callback: Messages.CallbackTypes.OnManualTaskFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    removeSubscription(subscription: Subscription, identity?: Identity): void;
+}
+export {};

package/dist/Clients/NotificationHttpClient.d.ts

@@ -0,0 +1,178 @@
+import { INotificationExtensionAdapter, Identity, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { Messages as ClientMessages } from '../Types/index';
+import { BaseClient } from './BaseClient';
+export interface INotificationHttpClient extends INotificationExtensionAdapter {
+    onConnected(callback: ClientMessages.CallbackTypes.OnConnected, subscribeOnce?: boolean): Subscription;
+    onDisconnected(callback: ClientMessages.CallbackTypes.OnDisconnected, subscribeOnce?: boolean): Subscription;
+    onReconnected(callback: ClientMessages.CallbackTypes.OnReconnected, subscribeOnce?: boolean): Subscription;
+}
+export declare class NotificationHttpClient extends BaseClient implements INotificationHttpClient {
+    removeSubscription(subscription: Subscription, identity?: Identity): void;
+    onConnected(callback: ClientMessages.CallbackTypes.OnConnected, subscribeOnce?: boolean, identity?: Identity): Subscription;
+    onDisconnected(callback: ClientMessages.CallbackTypes.OnDisconnected, subscribeOnce?: boolean, identity?: Identity): Subscription;
+    onReconnected(callback: ClientMessages.CallbackTypes.OnReconnected, subscribeOnce?: boolean, identity?: Identity): Subscription;
+    onProcessDeployed(callback: Messages.CallbackTypes.OnProcessDeployedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessUndeployed(callback: Messages.CallbackTypes.OnProcessUndeployedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessIsExecutableChanged(callback: Messages.CallbackTypes.OnProcessIsExecutableChangedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onCronjobEnabledChanged(callback: Messages.CallbackTypes.OnCronjobEnabledChangedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessStarting(callback: Messages.CallbackTypes.OnProcessStartingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessStarted(callback: Messages.CallbackTypes.OnProcessStartedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessResumed(callback: Messages.CallbackTypes.OnProcessStartedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessEnded(callback: Messages.CallbackTypes.OnProcessEndedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessOwnerChanged(callback: Messages.CallbackTypes.OnProcessOwnerChangedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessTerminated(callback: Messages.CallbackTypes.OnProcessTerminatedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessError(callback: Messages.CallbackTypes.OnProcessErrorCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessInstancesDeleted(callback: Messages.CallbackTypes.OnProcessInstancesDeletedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onCronjobCreated(callback: Messages.CallbackTypes.OnCronjobCreatedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onCronjobStopped(callback: Messages.CallbackTypes.OnCronjobStoppedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onCronjobUpdated(callback: Messages.CallbackTypes.OnCronjobUpdatedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onCronjobExecuted(callback: Messages.CallbackTypes.OnCronjobExecutedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onCronjobRemoved(callback: Messages.CallbackTypes.OnCronjobRemovedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onActivityReached(callback: Messages.CallbackTypes.OnActivityReachedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onActivityFinished(callback: Messages.CallbackTypes.OnActivityFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onEmptyActivityWaiting(callback: Messages.CallbackTypes.OnEmptyActivityWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onEmptyActivityFinished(callback: Messages.CallbackTypes.OnEmptyActivityFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onManualTaskWaiting(callback: Messages.CallbackTypes.OnManualTaskWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onManualTaskFinished(callback: Messages.CallbackTypes.OnManualTaskFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskWaiting(callback: Messages.CallbackTypes.OnUserTaskWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskFinished(callback: Messages.CallbackTypes.OnUserTaskFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskReserved(callback: Messages.CallbackTypes.OnUserTaskReservedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskReservationCanceled(callback: Messages.CallbackTypes.OnUserTaskReservationCanceledCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onBoundaryEventTriggered(callback: Messages.CallbackTypes.OnBoundaryEventTriggeredCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onIntermediateThrowEventTriggered(callback: Messages.CallbackTypes.OnIntermediateThrowEventTriggeredCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onIntermediateCatchEventReached(callback: Messages.CallbackTypes.OnIntermediateCatchEventReachedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onIntermediateCatchEventFinished(callback: Messages.CallbackTypes.OnIntermediateCatchEventFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onFlowNodeEventRetrySending(callback: Messages.CallbackTypes.OnFlowNodeEventRetrySendingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onMessageTriggered(callback: Messages.CallbackTypes.OnMessageTriggeredCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onSignalTriggered(callback: Messages.CallbackTypes.OnSignalTriggeredCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onStartEventFinished(callback: Messages.CallbackTypes.OnStartEventFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onEndEventFinished(callback: Messages.CallbackTypes.OnEndEventFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onExternalTaskCreated(callback: Messages.CallbackTypes.OnExternalTaskCreatedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onExternalTaskLocked(callback: Messages.CallbackTypes.OnExternalTaskLockedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onExternalTaskUnlocked(callback: Messages.CallbackTypes.OnExternalTaskUnlockedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onProcessInstanceMetadataChanged(callback: Messages.CallbackTypes.OnProcessInstanceMetadataChangedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onCorrelationMetadataChanged(callback: Messages.CallbackTypes.OnCorrelationMetadataChangedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+}

package/dist/Clients/ProcessDefinitionHttpClient.d.ts

@@ -0,0 +1,31 @@
+import { DataModels, IProcessDefinitionExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+type ProcessStartOptions<TPayload extends object> = DataModels.ProcessInstances.ProcessStartOptions<TPayload>;
+type ProcessStartResponse = DataModels.ProcessInstances.ProcessStartResponse;
+export declare class ProcessDefinitionHttpClient extends BaseClient implements IProcessDefinitionExtensionAdapter {
+    getAll(options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+    }): Promise<DataModels.ProcessDefinitions.ProcessDefinitionList>;
+    getById(processDefinitionId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    getByProcessModelId(processModelId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    persistProcessDefinitions(xml: string | Array<string>, options?: {
+        overwriteExisting?: boolean;
+        identity?: Identity;
+    }): Promise<void>;
+    deployFiles(filePaths: string | Array<string>, options?: {
+        overwriteExisting?: boolean;
+        identity?: Identity;
+    }): Promise<void>;
+    startProcessInstance<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitEndEvent<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitSpecificEndEvent<TPayload extends object>(options: DataModels.ProcessInstances.ProcessStartOptions<TPayload>, endEventId: string, identity?: Identity): Promise<ProcessStartResponse>;
+    /**
+     * @param deleteAllRelatedData Optional: If set to true, the Process Definition, as well as all related data, will be completely deleted.
+     *                             Otherwise, the Process Definition will only be flagged as deleted, but all data will be kept.
+     *                             Note that this won't do anything on engines with a version below v13.0.7.
+     */
+    deleteById(processDefinitionId: string, identity?: Identity, deleteAllRelatedData?: boolean): Promise<void>;
+}
+export {};

package/dist/Clients/ProcessDefinitionHttpClientNode.d.ts

@@ -0,0 +1,8 @@
+import { Identity } from '@5minds/processcube_engine_sdk';
+import { ProcessDefinitionHttpClient } from './ProcessDefinitionHttpClient';
+export declare class ProcessDefinitionHttpClientNode extends ProcessDefinitionHttpClient {
+    deployFiles(filePaths: string | Array<string>, options?: {
+        overwriteExisting?: boolean;
+        identity?: Identity;
+    }): Promise<void>;
+}

package/dist/Clients/ProcessInstanceHttpClient.d.ts

@@ -0,0 +1,23 @@
+import { DataModels, IProcessInstanceExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+export declare class ProcessInstanceHttpClient extends BaseClient implements IProcessInstanceExtensionAdapter {
+    query(query: DataModels.ProcessInstances.ProcessInstanceQuery, options?: {
+        identity?: Identity;
+        includeXml?: boolean;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.ProcessInstances.ProcessInstanceSortSettings;
+    }): Promise<DataModels.ProcessInstances.ProcessInstanceList>;
+    getProcessDefinition(processInstanceId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    getProcessModel(processInstanceId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    transferOwnership(processInstanceId: string, newOwner: DataModels.Iam.Identity, identity?: DataModels.Iam.Identity): Promise<void>;
+    terminateProcessInstance(processInstanceId: string, identity?: Identity): Promise<void>;
+    retryProcessInstance(processInstanceId: string, options?: {
+        flowNodeInstanceId?: string;
+        newStartToken?: any;
+        updateProcessModel?: boolean;
+        identity?: Identity;
+    }): Promise<void>;
+    deleteProcessInstances(processInstanceIds: string | Array<string>, deleteAllRelatedData?: boolean, identity?: Identity): Promise<void>;
+    private handleError;
+}

package/dist/Clients/ProcessModelHttpClient.d.ts

@@ -0,0 +1,29 @@
+import { DataModels, IProcessModelExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+type ProcessStartOptions<TPayload extends object> = DataModels.ProcessInstances.ProcessStartOptions<TPayload>;
+type ProcessStartResponse = DataModels.ProcessInstances.ProcessStartResponse;
+export declare class ProcessModelHttpClient extends BaseClient implements IProcessModelExtensionAdapter {
+    getAll(options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+    }): Promise<DataModels.ProcessDefinitions.ProcessModelList>;
+    getById(processModelId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    getByProcessInstanceId(processInstanceId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    startProcessInstance<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitEndEvent<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitSpecificEndEvent<TPayload extends object>(options: DataModels.ProcessInstances.ProcessStartOptions<TPayload>, endEventId: string, identity?: Identity): Promise<ProcessStartResponse>;
+    /**
+     * @param deleteAllRelatedData Optional: If set to true, the Process Definition, as well as all related data, will be completely deleted.
+     *                             Otherwise, the Process Definition will only be flagged as deleted, but all data will be kept.
+     *                             Note that this won't do anything on engines with a version below v13.0.7.
+     */
+    deleteDefinitionByProcessModelId(processModelId: string, options?: {
+        force?: boolean;
+        identity?: Identity;
+        deleteAllRelatedData?: boolean;
+    }): Promise<void>;
+    enableProcessModel(processModelId: string, identity?: Identity): Promise<void>;
+    disableProcessModel(processModelId: string, identity?: Identity): Promise<void>;
+}
+export {};

package/dist/Clients/UserMetadataStorageHttpClient.d.ts

@@ -0,0 +1,22 @@
+import { DataModels, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+export declare class UserMetadataStorageHttpClient extends BaseClient {
+    query<TKey extends string, TPIScope extends string, TFIScope extends string>(keys: readonly TKey[] | TKey, identity: Identity, options?: {
+        offset?: number;
+        limit?: number;
+        processInstanceScope?: readonly TPIScope[] | TPIScope;
+        flowNodeInstanceScope?: readonly TFIScope[] | TFIScope;
+    }): Promise<DataModels.UserMetadata.UserMetadataObject<TKey, TPIScope, TFIScope>>;
+    get(key: string, identity: Identity, options?: {
+        processInstanceScope?: string;
+        flowNodeInstanceScope?: string;
+    }): Promise<any>;
+    set(key: string, value: any, identity: Identity, options?: {
+        processInstanceScope?: string;
+        flowNodeInstanceScope?: string;
+    }): Promise<void>;
+    remove(key: string, identity: Identity, options?: {
+        processInstanceScope?: string;
+        flowNodeInstanceScope?: string;
+    }): Promise<void>;
+}

package/dist/Clients/UserTaskHttpClient.d.ts

@@ -0,0 +1,32 @@
+import { DataModels, IUserTaskExtensionAdapter, Identity, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+type UserTaskList = DataModels.FlowNodeInstances.UserTaskList;
+export declare class UserTaskHttpClient extends BaseClient implements IUserTaskExtensionAdapter {
+    query(query: DataModels.FlowNodeInstances.UserTaskQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.FlowNodeInstances.FlowNodeInstanceSortSettings;
+    }): Promise<UserTaskList>;
+    reserveUserTaskInstance(identity: Identity, flowNodeInstanceId: string, actualOwnerId: string): Promise<void>;
+    cancelUserTaskInstanceReservation(identity: Identity, flowNodeInstanceId: string): Promise<void>;
+    finishUserTask(userTaskInstanceId: string, userTaskResult: DataModels.FlowNodeInstances.UserTaskResult, identity?: Identity): Promise<void>;
+    onUserTaskWaiting(callback: Messages.CallbackTypes.OnUserTaskWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskFinished(callback: Messages.CallbackTypes.OnUserTaskFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskReserved(callback: Messages.CallbackTypes.OnUserTaskReservedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskReservationCanceled(callback: Messages.CallbackTypes.OnUserTaskReservationCanceledCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    removeSubscription(subscription: Subscription, identity?: Identity): void;
+}
+export {};

package/dist/Clients/index.d.ts

@@ -0,0 +1,18 @@
+export * from './AnonymousSessionHttpClient';
+export * from './ApplicationInfoHttpClient';
+export * from './CorrelationHttpClient';
+export * from './CronjobHttpClient';
+export * from './DataObjectInstanceHttpClient';
+export * from './EmptyActivityHttpClient';
+export * from './EventHttpClient';
+export * from './ExternalTaskApiHttpClient';
+export * from './ExternalTaskHttpClient';
+export * from './FlowNodeInstanceHttpClient';
+export * from './ManualTaskHttpClient';
+export * from './NotificationHttpClient';
+export * from './ProcessDefinitionHttpClient';
+export * from './ProcessDefinitionHttpClientNode';
+export * from './ProcessModelHttpClient';
+export * from './ProcessInstanceHttpClient';
+export * from './UserTaskHttpClient';
+export * from './UserMetadataStorageHttpClient';

package/dist/ExternalTaskWorker.d.ts

@@ -0,0 +1,32 @@
+import { ExternalTask, Identity } from '@5minds/processcube_engine_sdk';
+import { HandleExternalTaskAction, IExternalTaskWorkerConfig } from './Types/index';
+export type WorkerErrorHandler = (errorType: 'fetchAndLock' | 'extendLock' | 'processExternalTask' | 'finishExternalTask', error: Error, externalTask?: ExternalTask<any>) => void;
+export declare class ExternalTaskWorker<TExternalTaskPayload, TResultPayload extends object> {
+    private readonly _workerId;
+    private readonly lockDuration;
+    private readonly topic;
+    private readonly maxTasks;
+    private readonly longpollingTimeout;
+    private readonly processingFunction;
+    private readonly payloadFilter;
+    private _identity;
+    private _pollingActive;
+    private externalTaskClient;
+    private customErrorHandler;
+    constructor(engineUrl: string, topic: string, processingFunction: HandleExternalTaskAction<TExternalTaskPayload, TResultPayload>, config?: IExternalTaskWorkerConfig);
+    get identity(): Identity;
+    set identity(value: Identity);
+    get workerId(): string;
+    get pollingIsActive(): boolean;
+    onWorkerError(callback: WorkerErrorHandler): void;
+    start(): void;
+    stop(): void;
+    dispose(): void;
+    private processExternalTasks;
+    private fetchAndLockExternalTasks;
+    private executeExternalTask;
+    private extendLocks;
+    private processResult;
+    private handleExternalTaskExecutionError;
+    private sleep;
+}

package/dist/HttpClient.d.ts

@@ -0,0 +1,26 @@
+export interface IResponse<TResult> {
+    result: TResult;
+    status: number;
+}
+export interface IRequestOptions {
+    timeout?: number;
+    headers?: {
+        [name: string]: string | Array<string>;
+    };
+}
+export declare class HttpClient {
+    private url;
+    private httpSuccessResponseCode;
+    private httpRedirectResponseCode;
+    constructor(url: string);
+    get<TResponse>(url: string, options?: IRequestOptions): Promise<IResponse<TResponse>>;
+    post<TPayload, TResult>(url: string, data: TPayload, options?: IRequestOptions): Promise<IResponse<TResult>>;
+    put<TResult>(url: string, data: TResult, options?: IRequestOptions): Promise<IResponse<TResult>>;
+    delete<TResult>(url: string, options?: IRequestOptions): Promise<IResponse<TResult>>;
+    private addPrefixToUrl;
+    private buildHeaders;
+    private evaluateResponse;
+    private responseIsAnError;
+    private createAndThrowError;
+    private tryParseStringtoJson;
+}

package/dist/Types/CallbackTypes.d.ts

@@ -0,0 +1,39 @@
+import { CronjobEventMessage, EventMessage, ExternalTaskCreatedMessage, ExternalTaskLockedMessage, ExternalTaskUnlockedMessage, ProcessDeploymentMessage, ProcessInstancesDeletedMessage, ProcessIsExecutableChangedMessage, UserTaskFinishedMessage } from '@5minds/processcube_engine_sdk';
+/**
+ * See https://socket.io/docs/v3/client-api/index.html#Event-%E2%80%98disconnect%E2%80%99 for more information.
+ */
+export declare type OnConnected = () => void | Promise<void>;
+export declare type OnDisconnected = (reason: string) => void | Promise<void>;
+export declare type OnReconnected = (attempt: number) => void | Promise<void>;
+export declare type OnProcessDeployedCallback = (message: ProcessDeploymentMessage) => void | Promise<void>;
+export declare type OnProcessInstancesDeletedCallback = (message: ProcessInstancesDeletedMessage) => void | Promise<void>;
+export declare type OnProcessIsExecutableChangedCallback = (message: ProcessIsExecutableChangedMessage) => void | Promise<void>;
+export declare type OnProcessUndeployedCallback = (message: ProcessDeploymentMessage) => void | Promise<void>;
+export declare type OnBoundaryEventTriggeredCallback = (boundaryEventTriggered: EventMessage) => void | Promise<void>;
+export declare type OnIntermediateThrowEventTriggeredCallback = (intermediateThrowEventTriggered: EventMessage) => void | Promise<void>;
+export declare type OnIntermediateCatchEventReachedCallback = (intermediateCatchEventReached: EventMessage) => void | Promise<void>;
+export declare type OnIntermediateCatchEventFinishedCallback = (intermediateCatchEventFinished: EventMessage) => void | Promise<void>;
+export declare type OnActivityReachedCallback = (activityReached: EventMessage) => void | Promise<void>;
+export declare type OnActivityFinishedCallback = (activityFinished: EventMessage) => void | Promise<void>;
+export declare type OnEmptyActivityWaitingCallback = (userTaskWaiting: EventMessage) => void | Promise<void>;
+export declare type OnEmptyActivityFinishedCallback = (userTaskFinished: EventMessage) => void | Promise<void>;
+export declare type OnManualTaskWaitingCallback = (manualTaskWaiting: EventMessage) => void | Promise<void>;
+export declare type OnManualTaskFinishedCallback = (manualTaskFinished: EventMessage) => void | Promise<void>;
+export declare type OnUserTaskWaitingCallback = (userTaskWaiting: EventMessage) => void | Promise<void>;
+export declare type OnUserTaskFinishedCallback = (userTaskFinished: UserTaskFinishedMessage) => void | Promise<void>;
+export declare type OnUserTaskReservedCallback = (userTaskWaiting: EventMessage) => void | Promise<void>;
+export declare type OnUserTaskReservationCanceledCallback = (userTaskFinished: UserTaskFinishedMessage) => void | Promise<void>;
+export declare type OnProcessStartingCallback = (processStarting: EventMessage) => void | Promise<void>;
+export declare type OnProcessStartedCallback = (processStarted: EventMessage) => void | Promise<void>;
+export declare type OnProcessErrorCallback = (processError: EventMessage) => void | Promise<void>;
+export declare type OnProcessEndedCallback = (processEnded: EventMessage) => void | Promise<void>;
+export declare type OnProcessOwnerChangedCallback = (processOwnerChanged: EventMessage) => void | Promise<void>;
+export declare type OnProcessTerminatedCallback = (processTerminated: EventMessage) => void | Promise<void>;
+export declare type OnCronjobExecutedCallback = (cronjobExecuted: CronjobEventMessage) => void | Promise<void>;
+export declare type OnCronjobStoppedCallback = (cronjobStopped: CronjobEventMessage) => void | Promise<void>;
+export declare type OnCronjobUpdatedCallback = (cronjobUpdated: CronjobEventMessage) => void | Promise<void>;
+export declare type OnCronjobCreatedCallback = (cronjobCreated: CronjobEventMessage) => void | Promise<void>;
+export declare type OnCronjobRemovedCallback = (cronjobRemoved: CronjobEventMessage) => void | Promise<void>;
+export declare type OnExternalTaskCreatedCallback = (externaTask: ExternalTaskCreatedMessage) => void | Promise<void>;
+export declare type OnExternalTaskLockedCallback = (externaTask: ExternalTaskLockedMessage) => void | Promise<void>;
+export declare type OnExternalTaskUnlockedCallback = (externaTask: ExternalTaskUnlockedMessage) => void | Promise<void>;

package/dist/Types/IExternalTaskWorker.d.ts

@@ -0,0 +1,34 @@
+import { ExternalTask, Identity } from '@5minds/processcube_engine_sdk';
+/**
+ * Definition of the HandleExternalTask Callback.
+ */
+export type HandleExternalTaskAction<TPayload, TResult extends object> = (payload: TPayload, externalTask?: ExternalTask<TPayload>) => TResult | Promise<TResult>;
+/**
+ * Periodically fetches, locks and processes ExternalTasks for a given topic.
+ */
+export interface IExternalTaskWorker {
+    /**
+     * Id of worker
+     */
+    workerId: string;
+    /**
+     * Tells the worker to start polling for ExternalTasks.
+     */
+    start(): void;
+    /**
+     * Tells the worker to stop polling for ExternalTasks.
+     */
+    stop(): void;
+    /**
+     * Disposes the worker and its dependencies.
+     */
+    dispose(): void;
+}
+export interface IExternalTaskWorkerConfig {
+    workerId?: string;
+    lockDuration?: number;
+    maxTasks?: number;
+    longpollingTimeout?: number;
+    identity?: Identity;
+    payloadFilter?: RegExp;
+}