@5minds/processcube_engine_sdk 3.3.0

package/dist/Errors/BaseError.d.ts

@@ -0,0 +1,14 @@
+export declare function isEngineError(error: Error | BaseError | any): boolean;
+export type IClassOf<TClass> = new (...args: Array<any>) => TClass;
+export type ErrorCategory = 'process' | 'setup' | 'extension';
+export declare class BaseError extends Error {
+    code: number;
+    additionalInformation: any;
+    category?: ErrorCategory;
+    fatal: boolean;
+    isEngineError: boolean;
+    constructor(code: number, message: string, category?: ErrorCategory);
+    static deserialize(serializedError: string, reviverFunction?: (key: string, value: any) => any): BaseError;
+    serialize(): string;
+    private setCategoryPrefix;
+}

package/dist/Errors/ClientErrors.d.ts

@@ -0,0 +1,91 @@
+import { BaseError, ErrorCategory } from './BaseError';
+export declare class AuthenticationTimeoutError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class BadRequestError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class ConflictError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class ExpectationFailedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class FailedDependencyError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class ForbiddenError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class GoneError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class ImATeapotError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class LengthRequiredError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class LockedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class MethodNotAllowedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class MisdirectedRequestError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class NotAcceptableError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class NotFoundError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class PaymentRequiredError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class PolicyNotFulfilledError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class PreconditionFailedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class PreconditionRequiredError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class ProxyAuthenticationRequiredError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class RequestHeaderTooLargeError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class RequestTimeoutError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class RequestTooLargeError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class RequestedRangeNotSatisfiableError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class TooManyRequestsError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class UnauthorizedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class UnavaliableForLegalReasonsError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class UnprocessableEntityError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class UnsupportedMediaTypeError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class UpgradeRequiredError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class URLTooLongError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}

package/dist/Errors/ErrorCodes.d.ts

@@ -0,0 +1,53 @@
+export declare enum ErrorCodes {
+    ContinueError = 100,
+    SwitchingProtocolsError = 101,
+    ProcessingError = 102,
+    MultipleChoicesError = 300,
+    MovedError = 301,
+    FoundError = 302,
+    SeeOtherError = 303,
+    NotModifiedError = 304,
+    UseProxyError = 305,
+    TemporaryRedirectError = 307,
+    PermanentRedirectError = 308,
+    BadRequestError = 400,
+    UnauthorizedError = 401,
+    PaymentRequiredError = 402,
+    ForbiddenError = 403,
+    NotFoundError = 404,
+    MethodNotAllowedError = 405,
+    NotAcceptableError = 406,
+    ProxyAuthenticationRequiredError = 407,
+    RequestTimeoutError = 408,
+    ConflictError = 409,
+    GoneError = 410,
+    LengthRequiredError = 411,
+    PreconditionFailedError = 412,
+    RequestTooLargeError = 413,
+    URLTooLongError = 414,
+    UnsupportedMediaTypeError = 415,
+    RequestedRangeNotSatisfiableError = 416,
+    ExpectationFailedError = 417,
+    ImATeapotError = 418,
+    AuthenticationTimeoutError = 419,
+    PolicyNotFulfilledError = 420,
+    MisdirectedRequestError = 421,
+    UnprocessableEntityError = 422,
+    LockedError = 423,
+    FailedDependencyError = 424,
+    UpgradeRequiredError = 426,
+    PreconditionRequiredError = 428,
+    TooManyRequestsError = 429,
+    RequestHeaderTooLargeError = 431,
+    UnavaliableForLegalReasonsError = 451,
+    InternalServerError = 500,
+    NotImplementedError = 501,
+    BadGatewayError = 502,
+    ServiceUnavaliableError = 503,
+    GatewayTimeoutError = 504,
+    VersionNotSupportedError = 505,
+    InsufficientStorageError = 507,
+    LoopDetectedError = 508,
+    BandwithLimitExceededError = 509,
+    NetworkAuthenticationRequiredError = 511
+}

package/dist/Errors/InformationErrors.d.ts

@@ -0,0 +1,10 @@
+import { BaseError, ErrorCategory } from './BaseError';
+export declare class ContinueError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class ProcessingError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class SwitchingProtocolsError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}

package/dist/Errors/RedirectErrors.d.ts

@@ -0,0 +1,25 @@
+import { BaseError, ErrorCategory } from './BaseError';
+export declare class FoundError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class MovedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class MultipleChoicesError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class NotModifiedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class PermanentRedirectError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class SeeOtherError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class TemporaryRedirectError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class UseProxyError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}

package/dist/Errors/ServerErrors.d.ts

@@ -0,0 +1,31 @@
+import { BaseError, ErrorCategory } from './BaseError';
+export declare class BadGatewayError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class BandwithLimitExceededError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class GatewayTimeoutError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class InsufficientStorageError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class InternalServerError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class LoopDetectedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class NetworkAuthenticationRequiredError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class NotImplementedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class ServiceUnavaliableError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}
+export declare class VersionNotSupportedError extends BaseError {
+    constructor(message: string, category?: ErrorCategory);
+}

package/dist/Errors/index.d.ts

@@ -0,0 +1,6 @@
+export * from './BaseError';
+export * from './ErrorCodes';
+export * from './ClientErrors';
+export * from './InformationErrors';
+export * from './RedirectErrors';
+export * from './ServerErrors';

package/dist/ExtensionAdapter/AnonymousSessionExtensionAdapter.d.ts

@@ -0,0 +1,7 @@
+import { AnonymousSession } from '../DataModels/AnonymousSession';
+import { Identity } from '../DataModels/Iam/Identity';
+export interface IAnonymousSessionExtensionAdapter {
+    getAnonymousSessionById(sessionId: string): Promise<AnonymousSession>;
+    getAnonymousSessionsByUserId(userId: string): Promise<Array<AnonymousSession>>;
+    createAnonymousSessionForIdentity(identity: Identity): Promise<string>;
+}

package/dist/ExtensionAdapter/ApplicationInfoExtensionAdapter.d.ts

@@ -0,0 +1,5 @@
+import { DataModels } from '../index';
+export interface IApplicationInfoExtensionAdapter {
+    getApplicationInfo(): Promise<DataModels.ApplicationInfo>;
+    getAuthorityAddress(): Promise<string>;
+}

package/dist/ExtensionAdapter/CorrelationExtensionAdapter.d.ts

@@ -0,0 +1,14 @@
+import { DataModels, Identity } from '../index';
+export interface 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/ExtensionAdapter/CronjobExtensionAdapter.d.ts

@@ -0,0 +1,28 @@
+import { CronjobQuery, CronjobSortSettings, DataModels, DeployedCronjobList, Identity } from '../index';
+export interface 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/ExtensionAdapter/DataObjectInstanceExtensionAdapter.d.ts

@@ -0,0 +1,9 @@
+import { DataModels, Identity } from '../index';
+export interface IDataObjectInstanceExtensionAdapter {
+    query(query: DataModels.DataObjects.DataObjectInstanceQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.DataObjects.DataObjectSortSettings;
+    }): Promise<DataModels.DataObjects.DataObjectInstanceList>;
+}

package/dist/ExtensionAdapter/EmptyActivityExtensionAdapter.d.ts

@@ -0,0 +1,21 @@
+import { DataModels, Identity, Messages, Subscription } from '../index';
+type EmptyActivityList = DataModels.FlowNodeInstances.EmptyActivityList;
+export interface 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/ExtensionAdapter/EventExtensionAdapter.d.ts

@@ -0,0 +1,54 @@
+import { DataModels, Identity, Messages, Subscription } from '../index';
+type EventList = DataModels.FlowNodeInstances.EventList;
+export interface 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/ExtensionAdapter/ExternalTaskExtensionAdapter.d.ts

@@ -0,0 +1,18 @@
+import { DataModels, Identity } from '../index';
+type ExternalTask<TPayload> = DataModels.ExternalTasks.ExternalTask<TPayload>;
+export interface 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/ExtensionAdapter/FlowNodeInstanceExtensionAdapter.d.ts

@@ -0,0 +1,22 @@
+import { DataModels, Identity } from '../index';
+export interface 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/ExtensionAdapter/IIamExtensionAdapter.d.ts

@@ -0,0 +1,5 @@
+import { Identity } from '../index';
+export interface IIamExtensionAdapter {
+    ensureHasClaim(identity: Identity, claimName: string, claimValue?: string): Promise<void>;
+    getIdentity(token: string, sessionId?: string): Promise<Identity>;
+}

package/dist/ExtensionAdapter/ManualTaskExtensionAdapter.d.ts

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

package/dist/ExtensionAdapter/NotificationExtensionAdapter.d.ts

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

package/dist/ExtensionAdapter/ProcessDefinitionExtensionAdapter.d.ts

@@ -0,0 +1,25 @@
+import { DataModels, Identity } from '../index';
+type ProcessStartOptions<TPayload extends object> = DataModels.ProcessInstances.ProcessStartOptions<TPayload>;
+type ProcessStartResponse = DataModels.ProcessInstances.ProcessStartResponse;
+export interface IProcessDefinitionExtensionAdapter {
+    getAll(options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+    }): Promise<DataModels.ProcessDefinitions.ProcessDefinitionList>;
+    getById(processDefinitionId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    getByProcessModelId(processModelId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    persistProcessDefinitions(xml: string | Array<string>, options?: {
+        overwriteExisting?: boolean;
+        identity?: Identity;
+    }): Promise<void>;
+    deployFiles(filePaths: string | Array<string>, options?: {
+        overwriteExisting?: boolean;
+        identity?: Identity;
+    }): Promise<void>;
+    startProcessInstance<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitEndEvent<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitSpecificEndEvent<TPayload extends object>(options: DataModels.ProcessInstances.ProcessStartOptions<TPayload>, endEventId: string, identity?: Identity): Promise<ProcessStartResponse>;
+    deleteById(processDefinitionId: string, identity?: Identity, deleteAllRelatedData?: boolean): Promise<void>;
+}
+export {};