@5minds/processcube_engine_client 5.1.0 → 5.1.1

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,97 +8,97 @@ 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;
+        identity?: IdentityLike;
         /**
          * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
          */
@@ -105,7 +106,7 @@ export declare class NotificationHttpClient extends BaseClient implements INotif
     }): Promise<Subscription>;
     onUntypedTaskFinished(callback: Messages.CallbackTypes.OnUntypedTaskFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
         /**
          * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
          */
@@ -113,94 +114,94 @@ export declare class NotificationHttpClient extends BaseClient implements INotif
     }): 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,24 @@
-import { DataModels, IProcessInstanceExtensionAdapter, Identity } from '@5minds/processcube_engine_sdk';
+import { 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>;
+    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,8 +1,9 @@
-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;
@@ -10,10 +11,10 @@ export declare class UntypedTaskHttpClient extends BaseClient implements IUntype
     /**
      * @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, useLegacyEndpoint?: boolean): Promise<void>;
     onUntypedTaskWaiting(callback: Messages.CallbackTypes.OnUntypedTaskWaitingCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
         /**
          * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
          */
@@ -21,11 +22,11 @@ export declare class UntypedTaskHttpClient extends BaseClient implements IUntype
     }): Promise<Subscription>;
     onUntypedTaskFinished(callback: Messages.CallbackTypes.OnUntypedTaskFinishedCallback, options?: {
         subscribeOnce?: boolean;
-        identity?: Identity;
+        identity?: IdentityLike;
         /**
          * If true, will use the old "Empty Activity" Socket.IO Endpoint for receiving the notification.
          */
         useLegacyEndpoint?: boolean;
     }): 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/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,14 +8,21 @@ 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 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;

package/dist/IdentityAccessor.d.ts

@@ -0,0 +1,41 @@
+import { Identity, Logger } from '@5minds/processcube_engine_sdk';
+export declare class IdentityAccessor {
+    static wrap(identity?: IdentityLike, engineUrl?: string): IdentityAccessor;
+    private identityGetter;
+    private latestIdentity;
+    private expirationTimeInMs;
+    private id;
+    private identityAvailablePromise;
+    private identityAvailableResolve;
+    private identityAvailableReject;
+    private refreshTimeout;
+    protected logger: Logger;
+    private newIdentityCallbacks;
+    private asyncLock;
+    constructor(staticOrDynamicIdentity?: Identity | (() => Promise<Identity>) | (() => Identity));
+    getId(): string;
+    getIdentity(): Promise<Identity>;
+    /**
+     * 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;
+    dispose(): void;
+    protected getBaseMinRefreshTimeInMs(): number;
+    private refreshIdentityIfNeeded;
+    private getDecodedToken;
+}
+export type IdentityLike = Identity | (() => Promise<Identity>) | (() => Identity) | IdentityAccessor | ClientCredentialsConfig;
+export type ClientCredentialsConfig = {
+    authorityUrl?: string;
+    engineUrl?: string;
+    baseMinRefreshTimeInMs?: number;
+    clientId: string;
+    clientSecret: string;
+    scope: string;
+};

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;
 };
 /**

package/dist/commonjs/Client.js

@@ -3,13 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EngineClient = void 0;
 const ClientFactory_1 = require("./ClientFactory");
 const SocketIoManager_1 = require("./Clients/Lib/SocketIoManager");
-const dummyIdentity = {
-    token: 'ZHVtbXlfdG9rZW4=',
-    userId: 'dummy_token',
-};
+const IdentityAccessor_1 = require("./IdentityAccessor");
 class EngineClient {
     engineUrl;
-    identity;
+    identityAccessor;
     anonymousSessionClient;
     applicationInfoClient;
     correlationClient;
@@ -27,23 +24,23 @@ class EngineClient {
     userTaskClient;
     constructor(engineUrl, identity) {
         this.engineUrl = engineUrl;
-        this.identity = identity ?? dummyIdentity;
+        this.identityAccessor = IdentityAccessor_1.IdentityAccessor.wrap(identity, engineUrl);
         const socketIoManager = new SocketIoManager_1.SocketIoManager(this.engineUrl);
-        this.anonymousSessionClient = ClientFactory_1.ClientFactory.createAnonymousSessionClient(this.engineUrl, this.identity);
-        this.applicationInfoClient = ClientFactory_1.ClientFactory.createApplicationInfoClient(this.engineUrl, this.identity, socketIoManager);
-        this.correlationClient = ClientFactory_1.ClientFactory.createCorrelationClient(this.engineUrl, this.identity);
-        this.cronjobClient = ClientFactory_1.ClientFactory.createCronJobClient(this.engineUrl, this.identity);
-        this.dataObjectInstanceClient = ClientFactory_1.ClientFactory.createDataObjectInstanceClient(this.engineUrl, this.identity);
-        this.eventClient = ClientFactory_1.ClientFactory.createEventClient(this.engineUrl, this.identity, socketIoManager);
-        this.externalTaskClient = ClientFactory_1.ClientFactory.createExternalTaskClient(this.engineUrl, this.identity);
-        this.flowNodeInstanceClient = ClientFactory_1.ClientFactory.createFlowNodeInstanceClient(this.engineUrl, this.identity);
-        this.manualTaskClient = ClientFactory_1.ClientFactory.createManualTaskClient(this.engineUrl, this.identity, socketIoManager);
-        this.notificationClient = ClientFactory_1.ClientFactory.createNotificationClient(this.engineUrl, this.identity, socketIoManager);
-        this.processDefinitionClient = ClientFactory_1.ClientFactory.createProcessDefinitionClient(this.engineUrl, this.identity);
-        this.processInstanceClient = ClientFactory_1.ClientFactory.createProcessInstanceClient(this.engineUrl, this.identity);
-        this.processModelClient = ClientFactory_1.ClientFactory.createProcessModelClient(this.engineUrl, this.identity);
-        this.untypedTaskClient = ClientFactory_1.ClientFactory.createUntypedTaskClient(this.engineUrl, this.identity, socketIoManager);
-        this.userTaskClient = ClientFactory_1.ClientFactory.createUserTaskClient(this.engineUrl, this.identity, socketIoManager);
+        this.anonymousSessionClient = ClientFactory_1.ClientFactory.createAnonymousSessionClient(this.engineUrl, this.identityAccessor);
+        this.applicationInfoClient = ClientFactory_1.ClientFactory.createApplicationInfoClient(this.engineUrl, this.identityAccessor, socketIoManager);
+        this.correlationClient = ClientFactory_1.ClientFactory.createCorrelationClient(this.engineUrl, this.identityAccessor);
+        this.cronjobClient = ClientFactory_1.ClientFactory.createCronJobClient(this.engineUrl, this.identityAccessor);
+        this.dataObjectInstanceClient = ClientFactory_1.ClientFactory.createDataObjectInstanceClient(this.engineUrl, this.identityAccessor);
+        this.eventClient = ClientFactory_1.ClientFactory.createEventClient(this.engineUrl, this.identityAccessor, socketIoManager);
+        this.externalTaskClient = ClientFactory_1.ClientFactory.createExternalTaskClient(this.engineUrl, this.identityAccessor);
+        this.flowNodeInstanceClient = ClientFactory_1.ClientFactory.createFlowNodeInstanceClient(this.engineUrl, this.identityAccessor);
+        this.manualTaskClient = ClientFactory_1.ClientFactory.createManualTaskClient(this.engineUrl, this.identityAccessor, socketIoManager);
+        this.notificationClient = ClientFactory_1.ClientFactory.createNotificationClient(this.engineUrl, this.identityAccessor, socketIoManager);
+        this.processDefinitionClient = ClientFactory_1.ClientFactory.createProcessDefinitionClient(this.engineUrl, this.identityAccessor);
+        this.processInstanceClient = ClientFactory_1.ClientFactory.createProcessInstanceClient(this.engineUrl, this.identityAccessor);
+        this.processModelClient = ClientFactory_1.ClientFactory.createProcessModelClient(this.engineUrl, this.identityAccessor);
+        this.untypedTaskClient = ClientFactory_1.ClientFactory.createUntypedTaskClient(this.engineUrl, this.identityAccessor, socketIoManager);
+        this.userTaskClient = ClientFactory_1.ClientFactory.createUserTaskClient(this.engineUrl, this.identityAccessor, socketIoManager);
     }
     dispose() {
         this.anonymousSessionClient.dispose();
@@ -59,6 +56,7 @@ class EngineClient {
         this.processInstanceClient.dispose();
         this.untypedTaskClient.dispose();
         this.userTaskClient.dispose();
+        this.identityAccessor.dispose();
     }
     /**
      * Gets the url of the engine that this client is communicating with.