@5minds/processcube_engine_client 5.2.0-feature-9a5b28-m1yxdd4u → 6.0.0-alpha.10

package/dist/Clients/NotificationHttpClient.d.ts

@@ -1,4 +1,5 @@
-import { INotificationExtensionAdapter, Identity, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { INotificationExtensionAdapter, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { IdentityLike } from '../IdentityAccessor';
 import { Messages as ClientMessages } from '../Types/index';
 import { BaseClient } from './BaseClient';
 export interface INotificationHttpClient extends INotificationExtensionAdapter {
@@ -7,200 +8,192 @@ export interface INotificationHttpClient extends INotificationExtensionAdapter {
     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;
+    removeSubscription(subscription: Subscription, identity?: IdentityLike): void;
+    onConnected(callback: ClientMessages.CallbackTypes.OnConnected, subscribeOnce?: boolean, identity?: IdentityLike): Subscription;
+    onDisconnected(callback: ClientMessages.CallbackTypes.OnDisconnected, subscribeOnce?: boolean, identity?: IdentityLike): Subscription;
+    onReconnected(callback: ClientMessages.CallbackTypes.OnReconnected, subscribeOnce?: boolean, identity?: IdentityLike): Subscription;
     onActivityError(callback: Messages.CallbackTypes.OnActivityErrorCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessDeployed(callback: Messages.CallbackTypes.OnProcessDeployedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessUndeployed(callback: Messages.CallbackTypes.OnProcessUndeployedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessIsExecutableChanged(callback: Messages.CallbackTypes.OnProcessIsExecutableChangedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onCronjobEnabledChanged(callback: Messages.CallbackTypes.OnCronjobEnabledChangedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessStarting(callback: Messages.CallbackTypes.OnProcessStartingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessStarted(callback: Messages.CallbackTypes.OnProcessStartedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessResumed(callback: Messages.CallbackTypes.OnProcessStartedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessEnded(callback: Messages.CallbackTypes.OnProcessEndedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessOwnerChanged(callback: Messages.CallbackTypes.OnProcessOwnerChangedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessTerminated(callback: Messages.CallbackTypes.OnProcessTerminatedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessError(callback: Messages.CallbackTypes.OnProcessErrorCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessInstancesDeleted(callback: Messages.CallbackTypes.OnProcessInstancesDeletedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onCronjobCreated(callback: Messages.CallbackTypes.OnCronjobCreatedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onCronjobStopped(callback: Messages.CallbackTypes.OnCronjobStoppedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onCronjobUpdated(callback: Messages.CallbackTypes.OnCronjobUpdatedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onCronjobExecuted(callback: Messages.CallbackTypes.OnCronjobExecutedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onCronjobRemoved(callback: Messages.CallbackTypes.OnCronjobRemovedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onActivityReached(callback: Messages.CallbackTypes.OnActivityReachedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onActivityFinished(callback: Messages.CallbackTypes.OnActivityFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onActivityCanceled(callback: Messages.CallbackTypes.OnActivityCanceledCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUntypedTaskWaiting(callback: Messages.CallbackTypes.OnUntypedTaskWaitingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
-        /**
-         * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
-         */
-        useLegacyEndpoint?: boolean;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUntypedTaskFinished(callback: Messages.CallbackTypes.OnUntypedTaskFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
-        /**
-         * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
-         */
-        useLegacyEndpoint?: boolean;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onManualTaskWaiting(callback: Messages.CallbackTypes.OnManualTaskWaitingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onManualTaskFinished(callback: Messages.CallbackTypes.OnManualTaskFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUserTaskWaiting(callback: Messages.CallbackTypes.OnUserTaskWaitingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUserTaskFinished(callback: Messages.CallbackTypes.OnUserTaskFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUserTaskReserved(callback: Messages.CallbackTypes.OnUserTaskReservedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUserTaskReservationCanceled(callback: Messages.CallbackTypes.OnUserTaskReservationCanceledCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onBoundaryEventWaiting(callback: Messages.CallbackTypes.OnBoundaryEventWaitingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onBoundaryEventTriggered(callback: Messages.CallbackTypes.OnBoundaryEventTriggeredCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onBoundaryEventFinished(callback: Messages.CallbackTypes.OnBoundaryEventFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onIntermediateThrowEventTriggered(callback: Messages.CallbackTypes.OnIntermediateThrowEventTriggeredCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onIntermediateCatchEventReached(callback: Messages.CallbackTypes.OnIntermediateCatchEventReachedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onIntermediateCatchEventFinished(callback: Messages.CallbackTypes.OnIntermediateCatchEventFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onFlowNodeEventRetrySending(callback: Messages.CallbackTypes.OnFlowNodeEventRetrySendingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onMessageTriggered(callback: Messages.CallbackTypes.OnMessageTriggeredCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onSignalTriggered(callback: Messages.CallbackTypes.OnSignalTriggeredCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onStartEventFinished(callback: Messages.CallbackTypes.OnStartEventFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onEndEventFinished(callback: Messages.CallbackTypes.OnEndEventFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onExternalTaskCreated(callback: Messages.CallbackTypes.OnExternalTaskCreatedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onExternalTaskLocked(callback: Messages.CallbackTypes.OnExternalTaskLockedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onExternalTaskUnlocked(callback: Messages.CallbackTypes.OnExternalTaskUnlockedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onProcessInstanceMetadataChanged(callback: Messages.CallbackTypes.OnProcessInstanceMetadataChangedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onCorrelationMetadataChanged(callback: Messages.CallbackTypes.OnCorrelationMetadataChangedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onGatewayFinished(callback: Messages.CallbackTypes.OnGatewayFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
 }

package/dist/Clients/ProcessDefinitionHttpClient.d.ts

@@ -1,31 +1,32 @@
-import { DataModels, IProcessDefinitionExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { DataModels, IProcessDefinitionExtensionAdapter } from '@5minds/processcube_engine_sdk';
+import { IdentityLike } from '../IdentityAccessor';
 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;
+        identity?: IdentityLike;
         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>;
+    getById(processDefinitionId: string, identity?: IdentityLike): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    getByProcessModelId(processModelId: string, identity?: IdentityLike): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
     persistProcessDefinitions(xml: string | Array<string>, options?: {
         overwriteExisting?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<void>;
     deployFiles(filePaths: string | Array<string>, options?: {
         overwriteExisting?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): 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>;
+    startProcessInstance<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: IdentityLike): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitEndEvent<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: IdentityLike): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitSpecificEndEvent<TPayload extends object>(options: DataModels.ProcessInstances.ProcessStartOptions<TPayload>, endEventId: string, identity?: IdentityLike): 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>;
+    deleteById(processDefinitionId: string, identity?: IdentityLike, deleteAllRelatedData?: boolean): Promise<void>;
 }
 export {};

package/dist/Clients/ProcessDefinitionHttpClientNode.d.ts

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

package/dist/Clients/ProcessInstanceHttpClient.d.ts

@@ -1,23 +1,33 @@
-import { DataModels, IProcessInstanceExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { BpmnType, DataModels, IProcessInstanceExtensionAdapter } from '@5minds/processcube_engine_sdk';
+import { IdentityLike } from '../IdentityAccessor';
 import { BaseClient } from './BaseClient';
 export declare class ProcessInstanceHttpClient extends BaseClient implements IProcessInstanceExtensionAdapter {
     query(query: DataModels.ProcessInstances.ProcessInstanceQuery, options?: {
-        identity?: Identity;
+        identity?: IdentityLike;
         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>;
+    getChildProcessInstanceIds(processInstanceId: string, options: {
+        identity?: IdentityLike;
+        parentFlowNodeType?: BpmnType.subProcess | BpmnType.callActivity;
+        includeNested?: boolean;
+    }): Promise<Array<string>>;
+    getAncestorProcessInstanceIds(processInstanceId: string, options: {
+        identity?: IdentityLike;
+        onlyForEmbeddedProcesses?: boolean;
+    }): Promise<Array<string>>;
+    getProcessDefinition(processInstanceId: string, identity?: IdentityLike): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    getProcessModel(processInstanceId: string, identity?: IdentityLike): Promise<DataModels.ProcessDefinitions.ProcessModel>;
     transferOwnership(processInstanceId: string, newOwner: DataModels.Iam.Identity, identity?: DataModels.Iam.Identity): Promise<void>;
-    terminateProcessInstance(processInstanceId: string, identity?: Identity): Promise<void>;
+    terminateProcessInstance(processInstanceId: string, identity?: IdentityLike): Promise<void>;
     retryProcessInstance(processInstanceId: string, options?: {
         flowNodeInstanceId?: string;
         newStartToken?: any;
         updateProcessModel?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<void>;
-    deleteProcessInstances(processInstanceIds: string | Array<string>, deleteAllRelatedData?: boolean, identity?: Identity): Promise<void>;
+    deleteProcessInstances(processInstanceIds: string | Array<string>, deleteAllRelatedData?: boolean, identity?: IdentityLike): Promise<void>;
     private handleError;
 }

package/dist/Clients/ProcessModelHttpClient.d.ts

@@ -1,18 +1,19 @@
-import { DataModels, IProcessModelExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { DataModels, IProcessModelExtensionAdapter } from '@5minds/processcube_engine_sdk';
+import { IdentityLike } from '../IdentityAccessor';
 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;
+        identity?: IdentityLike;
         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>;
+    getById(processModelId: string, identity?: IdentityLike): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    getByProcessInstanceId(processInstanceId: string, identity?: IdentityLike): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    startProcessInstance<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: IdentityLike): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitEndEvent<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: IdentityLike): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitSpecificEndEvent<TPayload extends object>(options: DataModels.ProcessInstances.ProcessStartOptions<TPayload>, endEventId: string, identity?: IdentityLike): 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.
@@ -20,10 +21,10 @@ export declare class ProcessModelHttpClient extends BaseClient implements IProce
      */
     deleteDefinitionByProcessModelId(processModelId: string, options?: {
         force?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
         deleteAllRelatedData?: boolean;
     }): Promise<void>;
-    enableProcessModel(processModelId: string, identity?: Identity): Promise<void>;
-    disableProcessModel(processModelId: string, identity?: Identity): Promise<void>;
+    enableProcessModel(processModelId: string, identity?: IdentityLike): Promise<void>;
+    disableProcessModel(processModelId: string, identity?: IdentityLike): Promise<void>;
 }
 export {};

package/dist/Clients/UntypedTaskHttpClient.d.ts

@@ -1,31 +1,21 @@
-import { FlowNodeInstanceSortSettings, IUntypedTaskExtensionAdapter, Identity, Messages, Subscription, UntypedTaskList, UntypedTaskQuery } from '@5minds/processcube_engine_sdk';
+import { FlowNodeInstanceSortSettings, IUntypedTaskExtensionAdapter, Messages, Subscription, UntypedTaskList, UntypedTaskQuery } from '@5minds/processcube_engine_sdk';
+import { IdentityLike } from '../IdentityAccessor';
 import { BaseClient } from './BaseClient';
 export declare class UntypedTaskHttpClient extends BaseClient implements IUntypedTaskExtensionAdapter {
     query(query: UntypedTaskQuery, options?: {
-        identity?: Identity;
+        identity?: IdentityLike;
         offset?: number;
         limit?: number;
         sortSettings?: FlowNodeInstanceSortSettings;
     }): Promise<UntypedTaskList>;
-    /**
-     * @param useLegacyEndpoint If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
-     */
-    finishTask(taskInstanceId: string, identity?: Identity, useLegacyEndpoint?: boolean): Promise<void>;
+    finishTask(taskInstanceId: string, identity?: IdentityLike): Promise<void>;
     onUntypedTaskWaiting(callback: Messages.CallbackTypes.OnUntypedTaskWaitingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
-        /**
-         * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
-         */
-        useLegacyEndpoint?: boolean;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUntypedTaskFinished(callback: Messages.CallbackTypes.OnUntypedTaskFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
-        /**
-         * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
-         */
-        useLegacyEndpoint?: boolean;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
-    removeSubscription(subscription: Subscription, identity?: Identity): void;
+    removeSubscription(subscription: Subscription, identity?: IdentityLike): void;
 }

package/dist/Clients/UserTaskHttpClient.d.ts

@@ -1,32 +1,33 @@
-import { DataModels, IUserTaskExtensionAdapter, Identity, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { DataModels, IUserTaskExtensionAdapter, Messages, Subscription } from '@5minds/processcube_engine_sdk';
+import { IdentityLike } from '../IdentityAccessor';
 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;
+        identity?: IdentityLike;
         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>;
+    reserveUserTaskInstance(identity: IdentityLike, flowNodeInstanceId: string, actualOwnerId: string): Promise<void>;
+    cancelUserTaskInstanceReservation(identity: IdentityLike, flowNodeInstanceId: string): Promise<void>;
+    finishUserTask(userTaskInstanceId: string, userTaskResult: DataModels.FlowNodeInstances.UserTaskResult, identity?: IdentityLike): Promise<void>;
     onUserTaskWaiting(callback: Messages.CallbackTypes.OnUserTaskWaitingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUserTaskFinished(callback: Messages.CallbackTypes.OnUserTaskFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUserTaskReserved(callback: Messages.CallbackTypes.OnUserTaskReservedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
     onUserTaskReservationCanceled(callback: Messages.CallbackTypes.OnUserTaskReservationCanceledCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
     }): Promise<Subscription>;
-    removeSubscription(subscription: Subscription, identity?: Identity): void;
+    removeSubscription(subscription: Subscription, identity?: IdentityLike): void;
 }
 export {};

package/dist/Clients/index.d.ts

@@ -1,4 +1,3 @@
-export * from './AnonymousSessionHttpClient';
 export * from './ApplicationInfoHttpClient';
 export * from './CorrelationHttpClient';
 export * from './CronjobHttpClient';

package/dist/ExternalTaskExecution.d.ts

@@ -13,6 +13,7 @@ export declare class ExternalTaskExecution<TExternalTaskPayload, TResultPayload
     private abortSignalSubscription;
     private awaitAbortSignal;
     private abortSignalResolver;
+    private identityAccessor;
     private logger;
     constructor(externalTask: ExternalTask<TExternalTaskPayload>, processingFunction: HandleExternalTaskAction<TExternalTaskPayload, TResultPayload>, externalTaskClient: ExternalTaskApiClient, config: IExternalTaskWorkerConfig, topic: string, abortSignal: AbortSignal, customErrorHandler?: WorkerErrorHandler);
     execute(): Promise<void>;

package/dist/ExternalTaskWorker.d.ts

@@ -8,18 +8,27 @@ export declare class ExternalTaskWorker<TExternalTaskPayload, TResultPayload ext
     private readonly longpollingTimeout;
     private readonly processingFunction;
     private readonly payloadFilter;
-    private _identity;
+    private identityAccessor;
     private _pollingActive;
     private externalTaskClient;
     private customErrorHandler;
+    private onHeartbeatCallback;
     private abortController;
     private abortSignal;
     constructor(engineUrl: string, topic: string, processingFunction: HandleExternalTaskAction<TExternalTaskPayload, TResultPayload>, config?: IExternalTaskWorkerConfig);
+    /**
+     * @deprecated Use getIdentity instead.
+     */
     get identity(): Identity;
+    getIdentity(): Promise<Identity>;
+    /**
+     * @deprecated This is no longer safe to use. Identity should be set via the constructor.
+     */
     set identity(value: Identity);
     get workerId(): string;
     get pollingIsActive(): boolean;
     onWorkerError(callback: WorkerErrorHandler): void;
+    onHeartbeat(callback: () => void): void;
     start(): void;
     stop(): void;
     dispose(): void;

package/dist/IdentityAccessor.d.ts

@@ -0,0 +1,54 @@
+import { Identity, Logger } from '@5minds/processcube_engine_sdk';
+export type IdentityLike = Identity | (() => Promise<Identity>) | (() => Identity) | IdentityAccessor | ClientCredentialsConfig;
+export type ClientCredentialsConfig = {
+    authorityUrl?: string;
+    engineUrl?: string;
+    baseMinRefreshTimeInMs?: number;
+    clientId: string;
+    clientSecret: string;
+    scope: string;
+};
+export declare class IdentityAccessor {
+    static wrap(identity?: IdentityLike, engineUrl?: string): IdentityAccessor;
+    private identityGetter;
+    private latestIdentity;
+    private expirationTimeInMs;
+    protected id: string;
+    private identityAvailablePromise;
+    private identityAvailableResolve;
+    private identityAvailableReject;
+    protected refreshFailedCritically: boolean;
+    protected refreshTimeout: NodeJS.Timeout;
+    protected disposed: boolean;
+    protected isDynamicRefreshObject: boolean;
+    protected logger: Logger;
+    private newIdentityCallbacks;
+    private asyncLock;
+    constructor(staticOrDynamicIdentity?: Identity | (() => Promise<Identity>) | (() => Identity));
+    initialize(): void;
+    getId(): string;
+    getIdentitySync(): Identity;
+    canIdentityBeRefreshed(): boolean;
+    getIdentity(): Promise<Identity>;
+    forceImmediateIdentityRefresh(): Promise<void>;
+    /**
+     * This method only waits the first time the identity is retrieved from any remote source to ensure no missing references occur.
+     */
+    waitUntilIdentityIsAvailable(): Promise<void>;
+    /**
+     * @deprecated This method only exists for downward compatibility purposes, use getIdentity instead.
+     */
+    getIdentityStatic(): Identity;
+    onNewIdentity(callback: (identity: Identity) => Promise<void>): void;
+    removeOnNewIdentityListener(callback: (identity: Identity) => Promise<void>): void;
+    /**
+     * The IdentityAccesor creates a refresh timer, which needs to be disposed.
+     * This method should be called when the IdentityAccessor is not needed anymore.
+     * If any Client using this will be disposed, the IdentityAccessor will be disposed as well.
+     */
+    dispose(): void;
+    protected getBaseMinRefreshTimeInMs(): number;
+    private refreshIdentityPeriodically;
+    private fetchIdentity;
+    private getDecodedToken;
+}

package/dist/IdentityAccessorClientCredentials.d.ts

@@ -0,0 +1,14 @@
+import { Identity } from '@5minds/processcube_engine_sdk';
+import { ClientCredentialsConfig, IdentityAccessor } from './index';
+export declare class ClientCredentialsIdentityAccessor extends IdentityAccessor {
+    private config;
+    constructor(clientCredentialsConfig: ClientCredentialsConfig);
+    getFreshIdentity(clientCredentialsConfig: ClientCredentialsConfig): Promise<Identity>;
+    protected getBaseMinRefreshTimeInMs(): number;
+    private getNewToken;
+    private getOpenIdClient;
+    private getAuthorityUrl;
+    private getAuthorityUrlFromEngineUrl;
+    private ensureEndsWithoutSlash;
+    private hash;
+}

package/dist/Retry.d.ts

@@ -0,0 +1 @@
+export declare function executeWithRetry<TResult>(fn: () => Promise<TResult>, retryMessage?: string, errorsToRetry?: Array<string>, maxRetries?: number, retryInterval?: number): Promise<TResult>;

package/dist/Types/IExternalTaskWorker.d.ts

@@ -1,4 +1,5 @@
-import { ExternalTask, Identity } from '@5minds/processcube_engine_sdk';
+import { ExternalTask } from '@5minds/processcube_engine_sdk';
+import { IdentityLike } from '../IdentityAccessor';
 /**
  * Definition of the HandleExternalTask Callback.
  */
@@ -9,7 +10,7 @@ export type IExternalTaskWorkerConfig = {
     lockDuration?: number;
     maxTasks?: number;
     longpollingTimeout?: number;
-    identity?: Identity;
+    identity?: IdentityLike;
     payloadFilter?: RegExp;
 };
 /**