@5minds/processcube_engine_client 4.3.1

package/.prettierrc.json

@@ -0,0 +1,5 @@
+{
+  "singleQuote": true,
+  "printWidth": 180,
+  "arrowParens": "always"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2023 https://processcube.5minds.de/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,283 @@
+# Engine Client.ts
+
+A client for communicating with the `Engine`.
+
+It is written in TypeScript and implemented in NodeJS.
+
+## Quick example
+
+```ts
+import {EngineClient} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  const processInstances = await client.processInstances.query({});
+
+  console.log(processInstances);
+}
+
+run();
+```
+
+## How to use the client
+
+You only need to provide an url to the `Engine` you want to access.
+After that, the client is ready to use.
+
+You can either create a single EngineClient, which exposes references to all other clients,
+
+```ts
+import {EngineClient} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  const processInstances = await client.processInstances.query({}, null, 0, 100);
+
+  console.log(processInstances);
+}
+
+run();
+```
+
+or create multiple specific clients with the ClientFactory:
+
+```ts
+import {ClientFactory} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const processInstanceClient = ClientFactory.createProcessInstanceClient(engineUri);
+
+  const processInstances = await processInstanceClient.query({}, null, 0, 100);
+
+  console.log(processInstances);
+}
+
+run();
+```
+
+### Starting Process Instances
+
+You can start new Process Instances through `processDefinitionsClient.startProcessInstance(parameters)` -
+Resolves right after the Process Instance was started
+
+Where `parameters` is an object that collects all startup parameters.
+
+The following parameters are required:
+- `processModelId`: The ID of the Process Model to execute
+- `startEventId`: The ID of the Start Event by which to start the Process Model. Optional, if the Process Model only has one Start Event.
+
+In addition, the following optional parameters are available:
+- `correlationId`: The ID of the correlation to which this Process Instance belongs. If not provided, it will be auto-generated
+- `initialToken`: The initial process token with which to start the Process Instance
+- `parentProcessInstanceId`: When the Process Instance is supposed to be the Subprocess of another Process Instance,
+this contains the ID of the parent Process Instance
+
+or through
+
+`processDefinitionsClient.startProcessInstanceAndAwaitEndEvent(parameters)` -
+Resolves when the Process Instance has finished with any End Event
+
+or through
+
+`processDefinitionsClient.startProcessInstanceAndAwaitSpecificEndEvent(parameters, endEventId)` -
+Resolves after the ProcessInstance has reached a specific End Event
+and has additionally the required endEventId parameter:
+- `endEventId`: The ID of the End Event to wait for
+
+Examples:
+
+#### Start Process Instance and wait for it to start
+
+```ts
+import {EngineClient} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  await client.processDefinitions.startProcessInstance({processModelId: 'myProcessModelId'});
+}
+
+run();
+```
+
+#### Start Process Instance and wait for it to finish
+
+```ts
+import {EngineClient} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  await client.processDefinitions.startProcessInstanceAndAwaitEndEvent({processModelId: 'myProcessModelId'});
+}
+
+run();
+```
+
+#### Start Process Instance and wait for an End Event
+
+```ts
+import {EngineClient} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  await client.processDefinitions.startProcessInstanceAndAwaitSpecificEndEvent({processModelId: 'myProcessModelId'}, 'My_End_Event_1');
+}
+
+run();
+```
+
+#### Start Process Instance with custom payload and correlation ID
+
+```ts
+import {EngineClient} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  await client.processDefinitions.startProcessInstance({
+    processModelId: 'myProcessModelId',
+    correlationId: 'my_custom_correlation_id',
+    initialToken: {
+      hello: 'world',
+    },
+  });
+}
+
+run();
+```
+
+#### Start Process Instance as a sub process
+
+```ts
+import {EngineClient} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  await client.processDefinitions.startProcessInstance({
+    processModelId: 'myProcessModelId',
+    parentProcessInstanceId: 'Some-Other-Process-Instance-Id',
+  });
+}
+
+run();
+```
+
+### Code Samples
+
+You can find [executable code samples here](./samples/client) and [here](https://github.com/atlas-engine/ClientSamples/tree/develop/Client.ts).
+
+## Query UserTasks
+
+```ts
+import {EngineClient, DataModels} from '@5minds/processcube_engine_client';
+
+const engineUri = 'http://localhost:10560';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  const userTasks = await client.userTasks.query({
+    processModelId: 'myProcessModelId',
+    state: DataModels.FlowNodeInstances.FlowNodeInstanceState.suspended,
+  });
+
+  console.log(userTasks);
+}
+
+run();
+```
+
+## How to use External Task Workers
+
+An External Task worker is designed to process External Tasks associated with a BPMN ServiceTask.
+
+### Basic
+
+You need to provide three arguments to a worker:
+
+- The url of the Engine where the worker should connect to
+- The topic by which to poll External Tasks
+- A handler function for processing the External Tasks
+
+```ts
+import {EngineClient, DataModels} from '@5minds/processcube_engine_client';
+
+interface AddPayload {
+  number1: number;
+  number2: number;
+}
+
+interface AddResult {
+  sum: number;
+}
+
+const engineUri = 'http://localhost:10560';
+const topic = 'sum_numbers';
+
+async function run() {
+  const client = new EngineClient(engineUri);
+
+  const externalTaskWorker = await client.externalTasks.subscribeToExternalTaskTopic(topic, doAdd);
+
+  externalTaskWorker.start();
+}
+
+async function doAdd(
+  payload: AddPayload,
+  externalTask: DataModels.ExternalTasks.ExternalTask<AddPayload>,
+): Promise<AddResult> {
+
+  const result: AddResult = {
+    sum: payload.number1 + payload.number2,
+  };
+
+  console.log('Receive payload from process instance');
+  console.log(JSON.stringify(payload));
+
+  return Promise.resolve(result);
+}
+
+run();
+
+```
+
+Note that by subscribing to a single topic, you create a specific worker for this topic.
+
+### Starting and stopping
+
+Start the worker with:
+
+```ts
+externalTaskWorker.start();
+```
+
+And stop it with:
+
+```ts
+externalTaskWorker.stop();
+```
+
+### Code Samples
+
+You can find [executable code samples here](./samples/external_task_worker) and [here](https://github.com/atlas-engine/ClientSamples/tree/develop/Client.ts).

package/dist/Client.d.ts

@@ -0,0 +1,44 @@
+import { Identity } from '@5minds/processcube_engine_sdk';
+import * as Clients from './Clients/index';
+export declare class EngineClient {
+    private readonly engineUrl;
+    private readonly identity;
+    private readonly anonymousSessionClient;
+    private readonly applicationInfoClient;
+    private readonly correlationClient;
+    private readonly cronjobClient;
+    private readonly dataObjectInstanceClient;
+    private readonly emptyActivityClient;
+    private readonly eventClient;
+    private readonly externalTaskClient;
+    private readonly flowNodeInstanceClient;
+    private readonly manualTaskClient;
+    private readonly notificationClient;
+    private readonly processDefinitionClient;
+    private readonly processInstanceClient;
+    private readonly processModelClient;
+    private readonly userTaskClient;
+    private readonly userMetadataClient;
+    constructor(engineUrl: string, identity?: Identity);
+    dispose(): void;
+    /**
+     * Gets the url of the engine that this client is communicating with.
+     */
+    getEngineUrl(): string;
+    get anonymousSession(): Clients.AnonymousSessionHttpClient;
+    get applicationInfo(): Clients.ApplicationInfoHttpClient;
+    get correlations(): Clients.CorrelationHttpClient;
+    get cronjobs(): Clients.CronjobHttpClient;
+    get dataObjectInstances(): Clients.DataObjectInstanceHttpClient;
+    get emptyActivities(): Clients.EmptyActivityHttpClient;
+    get events(): Clients.EventHttpClient;
+    get externalTasks(): Clients.ExternalTaskClient;
+    get flowNodeInstances(): Clients.FlowNodeInstanceHttpClient;
+    get manualTasks(): Clients.ManualTaskHttpClient;
+    get notification(): Clients.NotificationHttpClient;
+    get processDefinitions(): Clients.ProcessDefinitionHttpClient;
+    get processInstances(): Clients.ProcessInstanceHttpClient;
+    get processModels(): Clients.ProcessModelHttpClient;
+    get userTasks(): Clients.UserTaskHttpClient;
+    get userMetadata(): Clients.UserMetadataStorageHttpClient;
+}

package/dist/ClientFactory.d.ts

@@ -0,0 +1,21 @@
+import { Identity } from '@5minds/processcube_engine_sdk';
+import { AnonymousSessionHttpClient, ApplicationInfoHttpClient, CorrelationHttpClient, CronjobHttpClient, DataObjectInstanceHttpClient, EmptyActivityHttpClient, EventHttpClient, ExternalTaskClient, FlowNodeInstanceHttpClient, ManualTaskHttpClient, NotificationHttpClient, ProcessDefinitionHttpClient, ProcessInstanceHttpClient, ProcessModelHttpClient, UserMetadataStorageHttpClient, UserTaskHttpClient } from './Clients/index';
+import { SocketIoManager } from './Clients/Lib/SocketIoManager';
+export declare const ClientFactory: {
+    createAnonymousSessionClient: (engineUrl: string, identity?: Identity) => AnonymousSessionHttpClient;
+    createApplicationInfoClient: (engineUrl: string, identity?: Identity, socketIoManager?: SocketIoManager) => ApplicationInfoHttpClient;
+    createCorrelationClient: (engineUrl: string, identity?: Identity) => CorrelationHttpClient;
+    createCronJobClient: (engineUrl: string, identity?: Identity) => CronjobHttpClient;
+    createDataObjectInstanceClient: (engineUrl: string, identity?: Identity) => DataObjectInstanceHttpClient;
+    createEmptyActivityClient: (engineUrl: string, identity?: Identity, socketIoManager?: SocketIoManager) => EmptyActivityHttpClient;
+    createEventClient: (engineUrl: string, identity?: Identity, socketIoManager?: SocketIoManager) => EventHttpClient;
+    createExternalTaskClient: (engineUrl: string, identity?: Identity) => ExternalTaskClient;
+    createFlowNodeInstanceClient: (engineUrl: string, identity?: Identity) => FlowNodeInstanceHttpClient;
+    createManualTaskClient: (engineUrl: string, identity?: Identity, socketIoManager?: SocketIoManager) => ManualTaskHttpClient;
+    createNotificationClient: (engineUrl: string, identity?: Identity, socketIoManager?: SocketIoManager) => NotificationHttpClient;
+    createProcessDefinitionClient: (engineUrl: string, identity?: Identity) => ProcessDefinitionHttpClient;
+    createProcessInstanceClient: (engineUrl: string, identity?: Identity) => ProcessInstanceHttpClient;
+    createProcessModelClient: (engineUrl: string, identity?: Identity) => ProcessModelHttpClient;
+    createUserTaskClient: (engineUrl: string, identity?: Identity, socketIoManager?: SocketIoManager) => UserTaskHttpClient;
+    createUserMetadataStorageClient: (engineUrl: string, identity?: Identity) => UserMetadataStorageHttpClient;
+};

package/dist/Clients/AnonymousSessionHttpClient.d.ts

@@ -0,0 +1,7 @@
+import { AnonymousSession, IAnonymousSessionExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+export declare class AnonymousSessionHttpClient extends BaseClient implements IAnonymousSessionExtensionAdapter {
+    getAnonymousSessionById(sessionId: string): Promise<AnonymousSession>;
+    getAnonymousSessionsByUserId(userId: string): Promise<Array<AnonymousSession>>;
+    createAnonymousSessionForIdentity(identity: Identity): Promise<string>;
+}

package/dist/Clients/ApplicationInfoHttpClient.d.ts

@@ -0,0 +1,10 @@
+import { DataModels, IApplicationInfoExtensionAdapter, Identity, Subscription } from '@5minds/processcube_engine_sdk';
+import { Messages as ClientMessages } from '../Types/index';
+import { BaseClient } from './BaseClient';
+export declare class ApplicationInfoHttpClient extends BaseClient implements IApplicationInfoExtensionAdapter {
+    getApplicationInfo(): Promise<DataModels.ApplicationInfo>;
+    getAuthorityAddress(): Promise<string>;
+    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;
+}

package/dist/Clients/BaseClient.d.ts

@@ -0,0 +1,26 @@
+import { Identity, Subscription } from '@5minds/processcube_engine_sdk';
+import { HttpClient, IRequestOptions } from '../HttpClient';
+import { SocketIoManager } from './Lib/SocketIoManager';
+export declare class BaseClient {
+    identity: Identity;
+    protected httpClient: HttpClient;
+    protected readonly socketIoManager: SocketIoManager;
+    private readonly baseUrl;
+    private readonly engineUrl;
+    constructor(engineUrl: string, identity: Identity, socketIoManager?: SocketIoManager);
+    get connected(): boolean;
+    /**
+     * Gets the url of the engine that this client is communicating with.
+     */
+    getEngineUrl(): string;
+    isSocketConnected(identity?: Identity): boolean;
+    disconnectSocket(identity: Identity): void;
+    dispose(): void;
+    protected buildUrl<TQuery, TSort>(url: string, offset?: number, limit?: number, query?: TQuery, sortSettings?: TSort): string;
+    protected createRequestAuthHeaders(identity: Identity): IRequestOptions;
+    protected createSocketIoSubscription(route: string, callback: Function, subscribeOnce: boolean, identity?: Identity): Subscription;
+    protected removeSocketIoSubscription(subscription: Subscription, identity?: Identity): void;
+    protected addParameterToUrl<TValue>(url: string, parameterName: string, parameterValue: TValue): string;
+    private encodeQueryAndAddParametersToUrl;
+    private encodeValue;
+}

package/dist/Clients/CorrelationHttpClient.d.ts

@@ -0,0 +1,15 @@
+import { DataModels, ICorrelationExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+export declare class CorrelationHttpClient extends BaseClient implements ICorrelationExtensionAdapter {
+    getAll(options?: {
+        identity?: Identity;
+        includeProcessInstances?: boolean;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.Correlation.CorrelationSortSettings;
+    }): Promise<DataModels.Correlation.CorrelationList>;
+    getById(correlationId: string, options?: {
+        identity?: Identity;
+        includeProcessInstances?: boolean;
+    }): Promise<DataModels.Correlation.Correlation>;
+}

package/dist/Clients/CronjobHttpClient.d.ts

@@ -0,0 +1,29 @@
+import { DataModels, ICronjobExtensionAdapter, Identity, DeployedCronjobList, CronjobQuery, CronjobSortSettings } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+export declare class CronjobHttpClient extends BaseClient implements ICronjobExtensionAdapter {
+    query(query: CronjobQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: CronjobSortSettings;
+    }): Promise<DeployedCronjobList>;
+    enableCronjob(processModelId: string, flowNodeId: string, identity?: Identity): Promise<void>;
+    disableCronjob(processModelId: string, flowNodeId: string, identity?: Identity): Promise<void>;
+    /**
+     * @deprecated Use "query" instead.
+     */
+    getActive(options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+    }): Promise<DataModels.Cronjob.CronjobList>;
+    /**
+     * @deprecated Use "query" instead.
+     */
+    queryHistory(query: DataModels.Cronjob.CronjobHistoryQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.Cronjob.CronjobHistorySortSettings;
+    }): Promise<DataModels.Cronjob.CronjobHistoryList>;
+}

package/dist/Clients/DataObjectInstanceHttpClient.d.ts

@@ -0,0 +1,10 @@
+import { DataModels, IDataObjectInstanceExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+export declare class DataObjectInstanceHttpClient extends BaseClient implements IDataObjectInstanceExtensionAdapter {
+    query(query: DataModels.DataObjects.DataObjectInstanceQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.DataObjects.DataObjectSortSettings;
+    }): Promise<DataModels.DataObjects.DataObjectInstanceList>;
+}

package/dist/Clients/EmptyActivityHttpClient.d.ts

@@ -0,0 +1,22 @@
+import { DataModels, IEmptyActivityExtensionAdapter, Identity, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+type EmptyActivityList = DataModels.FlowNodeInstances.EmptyActivityList;
+export declare class EmptyActivityHttpClient extends BaseClient implements IEmptyActivityExtensionAdapter {
+    query(query: DataModels.FlowNodeInstances.EmptyActivityQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.FlowNodeInstances.FlowNodeInstanceSortSettings;
+    }): Promise<EmptyActivityList>;
+    finishEmptyActivity(emptyActivityInstanceId: string, identity?: Identity): Promise<void>;
+    onEmptyActivityWaiting(callback: Messages.CallbackTypes.OnEmptyActivityWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onEmptyActivityFinished(callback: Messages.CallbackTypes.OnEmptyActivityFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    removeSubscription(subscription: Subscription, identity?: Identity): void;
+}
+export {};

package/dist/Clients/EventHttpClient.d.ts

@@ -0,0 +1,55 @@
+import { DataModels, IEventExtensionAdapter, Identity, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+type EventList = DataModels.FlowNodeInstances.EventList;
+export declare class EventHttpClient extends BaseClient implements IEventExtensionAdapter {
+    query(query: DataModels.FlowNodeInstances.EventQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.FlowNodeInstances.FlowNodeInstanceSortSettings;
+    }): Promise<EventList>;
+    triggerMessageEvent<TPayload>(messageName: string, options?: {
+        processInstanceId?: string;
+        payload?: TPayload;
+        identity?: Identity;
+    }): Promise<void>;
+    triggerSignalEvent<TPayload>(signalName: string, options?: {
+        processInstanceId?: string;
+        payload?: TPayload;
+        identity?: Identity;
+    }): Promise<void>;
+    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>;
+    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>;
+    removeSubscription(subscription: Subscription, identity?: Identity): void;
+}
+export {};

package/dist/Clients/ExternalTaskApiHttpClient.d.ts

@@ -0,0 +1,19 @@
+import { DataModels, IExternalTaskExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+type ExternalTask<TPayload> = DataModels.ExternalTasks.ExternalTask<TPayload>;
+export declare class ExternalTaskApiClient extends BaseClient implements IExternalTaskExtensionAdapter {
+    getAllDeployedTopics(identity?: Identity): Promise<Array<string>>;
+    fetchAndLockExternalTasks<TPayload>(workerId: string, topicNames: string | Array<string>, maxTasks: number, longPollingTimeout: number, lockDuration: number, payloadFilter?: RegExp, identity?: Identity): Promise<Array<ExternalTask<TPayload>>>;
+    extendLock(workerId: string, externalTaskId: string, additionalDuration: number, identity?: Identity): Promise<void>;
+    /**
+     * @deprecated Use handleError instead.
+     */
+    handleBpmnError(workerId: string, externalTaskId: string, error: DataModels.ExternalTasks.ExternalTaskBpmnError, identity?: Identity): Promise<void>;
+    /**
+     * @deprecated Use handleError instead.
+     */
+    handleServiceError(workerId: string, externalTaskId: string, error: DataModels.ExternalTasks.ExternalTaskServiceError, identity?: Identity): Promise<void>;
+    handleError(workerId: string, externalTaskId: string, error: DataModels.ExternalTasks.ExternalTaskServiceError, identity?: Identity): Promise<void>;
+    finishExternalTask<TResultType>(workerId: string, externalTaskId: string, result: TResultType, identity?: Identity): Promise<void>;
+}
+export {};

package/dist/Clients/ExternalTaskHttpClient.d.ts

@@ -0,0 +1,12 @@
+import { Identity } from '@5minds/processcube_engine_sdk';
+import { HandleExternalTaskAction, IExternalTaskWorker, IExternalTaskWorkerConfig } from '../Types/index';
+export declare class ExternalTaskClient {
+    private engineUrl;
+    private identity;
+    constructor(engineUrl: string, identity: Identity);
+    /**
+     * Gets the url of the engine that this client is communicating with.
+     */
+    getEngineUrl(): string;
+    subscribeToExternalTaskTopic<TExternalTaskPayload, TResultPayload extends object>(topic: string, processingFunction: HandleExternalTaskAction<TExternalTaskPayload, TResultPayload>, config?: IExternalTaskWorkerConfig): Promise<IExternalTaskWorker>;
+}

package/dist/Clients/FlowNodeInstanceHttpClient.d.ts

@@ -0,0 +1,23 @@
+import { DataModels, IFlowNodeInstanceExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BaseClient } from './BaseClient';
+export declare class FlowNodeInstanceHttpClient extends BaseClient implements IFlowNodeInstanceExtensionAdapter {
+    query(query: DataModels.FlowNodeInstances.GenericFlowNodeInstanceQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.FlowNodeInstances.FlowNodeInstanceSortSettings;
+    }): Promise<DataModels.FlowNodeInstances.FlowNodeInstanceList>;
+    finishEmptyActivity(emptyActivityInstanceId: string, identity?: Identity): Promise<void>;
+    finishManualTask(manualTaskInstanceId: string, identity?: Identity): Promise<void>;
+    finishUserTask(userTaskInstanceId: string, userTaskResult: DataModels.FlowNodeInstances.UserTaskResult, identity?: Identity): Promise<void>;
+    triggerMessageEvent<TPayload>(messageName: string, options?: {
+        processInstanceId?: string;
+        payload?: TPayload;
+        identity?: Identity;
+    }): Promise<void>;
+    triggerSignalEvent<TPayload>(signalName: string, options?: {
+        processInstanceId?: string;
+        payload?: TPayload;
+        identity?: Identity;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+import { AnonymousSession, DataModels, Cronjob } from '@5minds/processcube_engine_sdk';
+export declare function mapAnonymousSession(rawSession: any): AnonymousSession;
+export declare function mapProcessDefinition(rawDefinition: any): DataModels.ProcessDefinitions.ProcessDefinition;
+export declare function mapProcessModel(rawModel: any): DataModels.ProcessDefinitions.ProcessModel;
+export declare function mapFlowNodeInstance(data: any): DataModels.FlowNodeInstances.FlowNodeInstance;
+export declare function mapCallActivity(data: any): DataModels.FlowNodeInstances.CallActivityInstance;
+export declare function mapSubprocess(data: any): DataModels.FlowNodeInstances.SubprocessInstance;
+export declare function mapEmptyActivity(data: any): DataModels.FlowNodeInstances.EmptyActivityInstance;
+export declare function mapEvent(data: any): DataModels.FlowNodeInstances.EventInstance;
+export declare function mapManualTask(data: any): DataModels.FlowNodeInstances.ManualTaskInstance;
+export declare function mapReceiveTask(data: any): DataModels.FlowNodeInstances.ReceiveTaskInstance;
+export declare function mapServiceTask(data: any): DataModels.FlowNodeInstances.ServiceTaskInstance;
+export declare function mapUserTask(data: any): DataModels.FlowNodeInstances.UserTaskInstance;
+export declare function mapProcessToken(data: DataModels.FlowNodeInstances.ProcessToken): DataModels.FlowNodeInstances.ProcessToken;
+export declare function mapCronjobConfiguration(data: any): Cronjob;
+export declare function mapActiveCronjobConfiguration(data: any): DataModels.Cronjob.ActiveCronjob;
+export declare function mapCronjobHistory(data: any): DataModels.Cronjob.CronjobHistoryEntry;
+export declare function mapDataObjectInstance(data: any): DataModels.DataObjects.DataObjectInstance<object>;
+export declare function mapExternalTask<TPayload>(data: any): DataModels.ExternalTasks.ExternalTask<TPayload>;
+export declare function mapProcessInstance(data: any): DataModels.ProcessInstances.ProcessInstance;