@5minds/processcube_engine_sdk 3.3.0

package/dist/DataModels/UserMetadata.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     UserMetadata:
+ *       description: The user metadata
+ *       type: object
+ *       required:
+ *         - key
+ *         - value
+ *       properties:
+ *         key:
+ *           description: The key of the user metadata
+ *           type: string
+ *         value:
+ *           description: The value of the user metadata
+ *           oneOf:
+ *             - type: string
+ *             - type: number
+ *             - type: boolean
+ *             - type: object
+ *             - type: array
+ *         processInstanceScope:
+ *           description: The scope of the user metadata
+ *           type: string
+ *         flowNodeInstanceScope:
+ *           description: The scope of the user metadata
+ *           type: string
+ */
+export type UserMetadata<TKey extends string, TPIScope extends string, TFIScope extends string> = {
+    key: TKey;
+    value: any;
+    processInstanceScope?: TPIScope;
+    flowNodeInstanceScope?: TFIScope;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     UserMetadataObject:
+ *       description: A list of user metadata
+ *       type: object
+ *       required:
+ *         - metadata
+ *         - totalCount
+ *       properties:
+ *         metadata:
+ *           description: The user metadata
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/UserMetadata'
+ *         totalCount:
+ *           description: The total number of user metadata
+ *           type: number
+ */
+export type UserMetadataObject<TKey extends string, TPIScope extends string, TFIScope extends string> = {
+    metadata: UserMetadata<TKey, TPIScope, TFIScope>[];
+    totalCount: number;
+};

package/dist/DataModels/index.d.ts

@@ -0,0 +1,38 @@
+export * from './AnonymousSession';
+export * from './ApplicationInfo';
+export * from './Constants';
+export * from './Correlation';
+export * from './Cronjob/index';
+export * from './DataObjectInstance';
+export * from './ExternalTask/index';
+export * from './FlowNodeInstance/index';
+export * from './Iam/index';
+export * from './ProcessDefinition';
+export * from './ProcessInstance/index';
+export * from './UserMetadata';
+/**
+ * Only for backwards compatibility.
+ * Removing this would cause a ton of breaking changes with the client, the proxy and probably every extension.
+ */
+import * as appInfo from './ApplicationInfo';
+import * as correlation from './Correlation';
+import * as cronjob from './Cronjob/index';
+import * as dataObject from './DataObjectInstance';
+import * as externalTasks from './ExternalTask/index';
+import * as flowNodeInstances from './FlowNodeInstance/index';
+import * as iam from './Iam/index';
+import * as processDefinitions from './ProcessDefinition';
+import * as processInstances from './ProcessInstance/index';
+import * as userMetadata from './UserMetadata';
+export declare namespace DataModels {
+    export import ApplicationInfo = appInfo.ApplicationInfo;
+    export import Correlation = correlation;
+    export import Cronjob = cronjob;
+    export import DataObjects = dataObject;
+    export import ExternalTasks = externalTasks;
+    export import FlowNodeInstances = flowNodeInstances;
+    export import Iam = iam;
+    export import ProcessDefinitions = processDefinitions;
+    export import ProcessInstances = processInstances;
+    export import UserMetadata = userMetadata;
+}

package/dist/Engine.d.ts

@@ -0,0 +1,383 @@
+/// <reference types="node" />
+import { Identity } from './DataModels/Iam/index';
+import { EngineEventType, MiddlewareCallback } from './EngineEvents/index';
+import { IAnonymousSessionExtensionAdapter, IApplicationInfoExtensionAdapter, ICorrelationExtensionAdapter, ICronjobExtensionAdapter, IDataObjectInstanceExtensionAdapter, IEmptyActivityExtensionAdapter, IEventExtensionAdapter, IExternalTaskExtensionAdapter, IFlowNodeInstanceExtensionAdapter, IIamExtensionAdapter, IManualTaskExtensionAdapter, INotificationExtensionAdapter, IProcessDefinitionExtensionAdapter, IProcessInstanceExtensionAdapter, IProcessModelExtensionAdapter, IUserTaskExtensionAdapter } from './ExtensionAdapter';
+import { EventViewModel, FlowNodeViewModel } from './ProcessModel/index';
+import * as express from 'express';
+/**
+ * Describes the onLoad function, which can be exported by an extension.
+ * It will be called by the Engine on startup.
+ *
+ * Example implementation:
+ * export const onLoad: onLoadFunction = (engine: Engine) => {}
+ */
+export type OnLoad = (engine: Engine) => void | Promise<void>;
+export type EngineExtension = {
+    onLoad: OnLoad;
+};
+/**
+ * Takes a list of claims and returns a set of claims associated with this token.
+ * This is useful if you want to use your own set of claims with an identity, which do not match the engines default claims.
+ *
+ * The claims must be returned as JSON dictionary.
+ * For example:
+ *
+ * ```js
+ * {
+ *   can_manage_process_instances: true,
+ *   someLaneName: true,
+ * }
+ * ```
+ *
+ * @async
+ * @param originalClaims The claims associated with the identity.
+ * @param authToken      Optional: The original auth token. Can be omitted, if you're only interested in the claim list.
+ * @returns              The resolved claims.
+ */
+export type IdentityClaimResolver = (originalClaims: {
+    [claimName: string]: any;
+}, authToken?: string) => {
+    [claimName: string]: any;
+} | Promise<{
+    [claimName: string]: any;
+}>;
+export type CustomServiceTaskHandlerContext = {
+    token: {
+        current: object;
+        history: object;
+    };
+    correlationId: string;
+    correlationMetadata: any;
+    currentFlowNode: FlowNodeViewModel;
+    dataObjects: {
+        [dataObjectId: string]: any;
+    };
+    identity: Identity;
+    previousFlowNodeId: string;
+    processInstanceMetadata: any;
+};
+/**
+ * A CustomServiceTaskHandler is a used to execute custom Service Task Types - i.e. Service Task that are not External Service Tasks, or Http Service Tasks.
+ *
+ * @param  context Contains information like the current token, Correlation- & Process Instance metadata or the service task's View Model.
+ * @returns             A result set to use as End Token. Must be a JSON object.
+ */
+export type CustomServiceTaskHandler<TPayload extends Record<string, any>> = (context: CustomServiceTaskHandlerContext) => Promise<TPayload> | TPayload;
+export type CustomHttpRouteRequest = {
+    accepted: Array<express.MediaType>;
+    baseUrl: string;
+    body: object;
+    complete: boolean;
+    cookies: object;
+    fresh: boolean;
+    headers: object;
+    hostname: string;
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    identity: Identity;
+    ip: string;
+    ips: Array<string>;
+    method: string;
+    originalUrl: string;
+    params: object;
+    path: string;
+    protocol: string;
+    query: {
+        [key: string]: any;
+    };
+    rawHeaders: Array<string>;
+    route: any;
+    secure: boolean;
+    signedCookies: object;
+    stale: boolean;
+    subdomains: Array<string>;
+    xhr: boolean;
+};
+export declare enum HttpResponseActionType {
+    Send = "send",
+    Json = "json",
+    Jsonp = "jsonp",
+    Download = "download",
+    SendFile = "sendFile",
+    End = "end",
+    SendStatus = "sendStatus",
+    Redirect = "redirect"
+}
+export type HttpResponseAction = HttpSendAction | HttpJsonAction | HttpSendFileAction | HttpDownloadAction | HttpEndAction | HttpSendStatusAction | HttpRedirectAction;
+export type HttpSendAction = {
+    type: HttpResponseActionType.Send;
+    result?: string;
+};
+export type HttpJsonAction = {
+    type: HttpResponseActionType.Json | HttpResponseActionType.Jsonp;
+    result?: object;
+};
+export type HttpSendFileAction = {
+    type: HttpResponseActionType.SendFile;
+    path?: string;
+    options?: any;
+};
+export type HttpDownloadAction = {
+    type: HttpResponseActionType.Download;
+    path: string;
+    filename?: string;
+    options?: any;
+};
+export type HttpSendStatusAction = {
+    type: HttpResponseActionType.SendStatus;
+};
+export type HttpEndAction = {
+    type: HttpResponseActionType.End;
+    chunk?: any;
+    encoding?: BufferEncoding;
+};
+export type HttpRedirectAction = {
+    type: HttpResponseActionType.Redirect;
+    url: string;
+    statusCode?: number;
+};
+export type CustomHttpRouteResult = {
+    action: HttpResponseAction;
+    append?: {
+        [name: string]: string | Array<string> | null;
+    };
+    attachment?: string | null;
+    links?: {
+        [name: string]: string;
+    };
+    location?: string;
+    cookies?: Array<{
+        name: string;
+        value: string;
+        options?: express.CookieOptions;
+    }>;
+    clearCookies?: Array<{
+        name: string;
+        options?: express.CookieOptions;
+    }>;
+    set?: {
+        [name: string]: string;
+    };
+    status?: number;
+    trailers?: {
+        [key: string]: string;
+    };
+    type?: string;
+    vary?: string | Array<string>;
+};
+export type CustomHttpRouteHandler = (request: CustomHttpRouteRequest) => Promise<CustomHttpRouteResult> | CustomHttpRouteResult;
+export type RuntimeExpressionParameters = {
+    token?: {
+        current?: any;
+        history?: {
+            [flowNodeId: string]: any;
+        };
+    };
+    correlationId?: string;
+    correlationMetadata?: any;
+    identity?: {
+        token: string;
+        userId: string;
+        userToken: string;
+        claims: {
+            [key: string]: boolean;
+        };
+    };
+    processInstanceMetadata?: any;
+    currentDataObject?: any;
+    currentFlowNode?: FlowNodeViewModel;
+    previousFlowNodeId?: string;
+    dataObjects?: {
+        [dataObjectId: string]: any;
+    };
+    additionalProperties?: {
+        [key: string]: any;
+    };
+    allowNonObjectResults: boolean;
+};
+/**
+ * Contains interfaces for interaction with the Engine.
+ */
+export type Engine = {
+    /**
+     * Retrieves a section of the config by the given config key.
+     *
+     * @typedef TValue The expected type of the config to retrieve.
+     * @param key The key of the config to get.
+     * @returns   The retrieved config.
+     */
+    getConfig<TValue extends any>(key: string): TValue;
+    /**
+     * Registers a callback to execute before the resuming has started.
+     *
+     * @param callback The callback to call before the resuming has started.
+     */
+    onBeforeResuming(callback: () => void | Promise<void>): void;
+    /**
+     * Registers a callback to execute after the Engine has finished starting up.
+     *
+     * @param callback The callback to call after the Engine has finished starting up.
+     */
+    onReady(callback: () => void | Promise<void>): void;
+    /**
+     * Registers a resolver for mapping a list of identity claims to a new set of claims.
+     * The resolver takes a list of claims that an identity originally comes with and returns a new Set of claims that match the internal engine claims.
+     *
+     * Only one resolver can be active at any given time.
+     * Therefore, any existing resolvers will be overwritten.
+     *
+     * The claims must be returned as JSON dictionary.
+     * For example:
+     *
+     * ```js
+     * {
+     *   can_manage_process_instances: true,
+     *   someLaneName: true,
+     * }
+     * ```
+     *
+     * @param identityClaimResolver The function to use for mapping the identity claims.
+     */
+    registerIdentityClaimResolver(identityClaimResolver: IdentityClaimResolver): void;
+    /**
+     * Removes the currently registered Identity Claim Resolver middleware.
+     * Doesn't do anything, if no resolver has been set.
+     *
+     */
+    removeIdentityClaimResolver(): void;
+    /**
+     * Registers the given callback as an Event Middleware.
+     * This middleware gets called whenever a Log Event occurs at the Engine.
+     *
+     * @param callback The function to call when a Log Event occurs.
+     */
+    registerEventMiddleware<TPayload extends object>(callback: MiddlewareCallback<TPayload>): void;
+    /**
+     * Removes an Event Middleware by its id.
+     *
+     * @async
+     * @param callbackToRemove The callback to remove.
+     */
+    removeEventMiddleware(callbackToRemove: MiddlewareCallback<never>): void;
+    /**
+     * Registers the given callback as an Event Middleware for BPMN Message Events.
+     *
+     * @param   callback      The callback to execute, when a MessageEvent was received.
+     * @param   eventType     The EventType to listen for.
+     *                        If not specified 'OnFlowNodeExited' will be used.
+     *                        The callback will only be executed when events with the given EventType are received.
+     */
+    registerMessageEventMiddleware<TPayload extends object>(callback: MiddlewareCallback<TPayload>, eventType?: EngineEventType.OnFlowNodeEntered | EngineEventType.OnFlowNodeExited): void;
+    /**
+     * Registers the given callback as an Event Middleware for BPMN Message Events.
+     *
+     * @param   messageName   The name of the message to listen for.
+     *                        If set, the callback will only be executed when messages with the given name are received.
+     * @param   callback      The callback to execute, when a MessageEvent was received.
+     * @param   eventType     The EventType to listen for.
+     *                        If not specified 'OnFlowNodeExited' will be used.
+     *                        The callback will only be executed when events with the given EventType are received.
+     */
+    registerMessageEventMiddleware<TPayload extends object>(messageName: string, callback: MiddlewareCallback<TPayload>, eventType?: EngineEventType.OnFlowNodeEntered | EngineEventType.OnFlowNodeExited): void;
+    /**
+     * Registers the given callback as an Event Middleware for BPMN Signal Events.
+     *
+     * @param   callback    The callback to execute, when a SignalEvent was received.
+     * @param   eventType   The EventType to listen for.
+     *                      If not specified 'OnFlowNodeExited' will be used.
+     *                      The callback will only be executed when events with the given EventType are received.
+     */
+    registerSignalEventMiddleware<TPayload extends object>(callback: MiddlewareCallback<TPayload>, eventType?: EngineEventType.OnFlowNodeEntered | EngineEventType.OnFlowNodeExited): void;
+    /**
+     * Registers the given callback as an Event Middleware for BPMN Signal Events.
+     *
+     * @param   signalName  The name of the signal to listen for.
+     *                      If set, the callback will only be executed when signals with the given name are received.
+     * @param   callback    The callback to execute, when a SignalEvent was received.
+     * @param   eventType   The EventType to listen for.
+     *                      If not specified 'OnFlowNodeExited' will be used.
+     *                      The callback will only be executed when events with the given EventType are received.
+     */
+    registerSignalEventMiddleware<TPayload extends object>(signalName: string, callback: MiddlewareCallback<TPayload>, eventType?: EngineEventType.OnFlowNodeEntered | EngineEventType.OnFlowNodeExited): void;
+    /**
+     * Triggers a message event.
+     *
+     * @async
+     * @param messageName        The name of the message to trigger.
+     * @param payload            Optional: The payload with which to trigger the message.
+     * @param processInstanceId  Optional: The ID of the ProcessInstance on which to trigger the message event.
+     * @param identity           Optional: The requesting users identity.
+     * @param correlationId      Optional: The ID of a correlation to which the message should belong.
+     * @returns                  A guid to identify the corresponding acknowledgement event.
+     */
+    triggerMessageEvent: <TPayload extends object>(messageName: string, payload?: TPayload, processInstanceId?: string, identity?: Identity, correlationId?: string) => Promise<string>;
+    /**
+     * Triggers a message start event.
+     *
+     * @async
+     * @param messageName        The name of the message to trigger.
+     * @param payload            Optional: The payload with which to trigger the message.
+     * @param identity           Optional: The requesting users identity.
+     * @param correlationId      Optional: The ID of a correlation to which the message should belong.
+     * @returns                  A guid to identify the corresponding acknowledgement event.
+     */
+    triggerMessageStartEvent: <TPayload extends object>(messageName: string, payload?: TPayload, identity?: Identity, correlationId?: string) => Promise<string>;
+    /**
+     * Triggers a signal event.
+     *
+     * @async
+     * @param signalName         The name of the signal to trigger.
+     * @param payload            Optional: The payload with which to trigger the signal.
+     * @param processInstanceId  Optional: The ID of the ProcessInstance on which to trigger the signal event.
+     * @param identity           Optional: The requesting users identity.
+     * @param correlationId      Optional: The ID of a correlation to which the signal should belong.
+     * @returns                  A guid to identify the corresponding acknowledgement event.
+     */
+    triggerSignalEvent: <TPayload extends object>(signalName: string, payload?: TPayload, processInstanceId?: string, identity?: Identity, correlationId?: string) => Promise<string>;
+    /**
+     * Triggers a signal start event.
+     *
+     * @async
+     * @param signalName         The name of the signal to trigger.
+     * @param payload            Optional: The payload with which to trigger the signal.
+     * @param identity           Optional: The requesting users identity.
+     * @param correlationId      Optional: The ID of a correlation to which the signal should belong.
+     * @returns                  A guid to identify the corresponding acknowledgement event.
+     */
+    triggerSignalStartEvent: <TPayload extends object>(signalName: string, payload?: TPayload, identity?: Identity, correlationId?: string) => Promise<string>;
+    /**
+     * Returns a distinct list of all message events currently deployed to the engine.
+     *
+     * @async
+     * @param processModelIds Optional: Only return message events for the given processModelIds.
+     */
+    getMessageEvents(processModelIds?: string | Array<string>): Promise<Array<EventViewModel>>;
+    /**
+     * Returns a distinct list of all signal events currently deployed to the engine.
+     *
+     * @async
+     * @param processModelIds Optional: Only return signal events for the given processModelIds.
+     */
+    getSignalEvents(processModelIds?: string | Array<string>): Promise<Array<EventViewModel>>;
+    anonymousSessions: IAnonymousSessionExtensionAdapter;
+    registerCustomServiceTask<TPayload extends object>(serviceTaskType: string, serviceTaskHandler: CustomServiceTaskHandler<TPayload>): void;
+    removeCustomServiceTask(serviceTaskType: string): void;
+    registerHttpRoute(httpRoute: string, method: 'get' | 'post' | 'put' | 'delete', routeHandler: CustomHttpRouteHandler): void;
+    executeRuntimeExpression<TExpectedResult>(expression: string, params: RuntimeExpressionParameters): Promise<TExpectedResult>;
+    applicationInfo: IApplicationInfoExtensionAdapter;
+    correlations: ICorrelationExtensionAdapter;
+    cronjobs: ICronjobExtensionAdapter;
+    dataObjectInstances: IDataObjectInstanceExtensionAdapter;
+    emptyActivities: IEmptyActivityExtensionAdapter;
+    events: IEventExtensionAdapter;
+    externalTasks: IExternalTaskExtensionAdapter;
+    flowNodeInstances: IFlowNodeInstanceExtensionAdapter;
+    iam: IIamExtensionAdapter;
+    manualTasks: IManualTaskExtensionAdapter;
+    notification: INotificationExtensionAdapter;
+    processDefinitions: IProcessDefinitionExtensionAdapter;
+    processInstances: IProcessInstanceExtensionAdapter;
+    processModels: IProcessModelExtensionAdapter;
+    userTasks: IUserTaskExtensionAdapter;
+};

package/dist/EngineConfiguration.d.ts

@@ -0,0 +1,95 @@
+import { LogLevel } from './EngineEvents';
+export declare interface IConfigurator {
+    /**
+     * Retrieves the configs registered under the given key.
+     *
+     * @param key The key of the configs to get.
+     */
+    get<TValue>(key: string): TValue;
+}
+export declare type EngineConfiguration = {
+    application?: ApplicationConfig;
+    httpServer?: HttpServerConfig;
+    httpClient?: HttpClientConfig;
+    iam: IAMConfiguration;
+    database: DatabaseConfig;
+    logging?: LoggingConfiguration;
+    tlsConfig?: TlsConfig;
+    extraInfo?: any;
+};
+export declare type ApplicationConfig = {
+    name: string;
+    id: string;
+    touchFileOnReady?: string;
+};
+export declare type DatabaseConfig = {
+    username?: string;
+    password?: string;
+    database?: string;
+    storage?: string;
+    host?: string;
+    port?: number;
+    ssl?: boolean;
+    dialect?: string;
+    dialectOptions?: any;
+    supportBigNumbers?: boolean;
+    resetPasswordRequestTimeToLive?: number;
+    logging?: boolean;
+    schema?: string;
+    pool?: PoolConfig;
+    retry?: {
+        maxDuration?: string;
+    };
+};
+export declare type PoolConfig = {
+    /**
+     * Maximum number of connections in the connection pool. Default is 5. The connections will be split among all the engine workers.
+     * For a more accurate division, use worker specific pool settings.
+     * Note that "max" and the worker-specific settings are mutually exclusive. You can only use one OR the other.
+     */
+    max?: number;
+    /**
+     * Maximum number of connections in the connection pool for ExternalTasks.
+     * Must be used in conjunction with maxForQueryRequests and maxForProcessExecution.
+     *
+     * Note that "max" and the worker-specific settings are mutually exclusive. You can only use one OR the other.
+     */
+    maxForExternalTasks?: number;
+    /**
+     * Maximum number of connections in the connection pool for Query requests.
+     * Must be used in conjunction with maxForExternalTasks and maxForProcessExecution.
+     *
+     * Note that "max" and the worker-specific settings are mutually exclusive. You can only use one OR the other.
+     */
+    maxForQueryRequests?: number;
+    /**
+     * Maximum number of connections in the connection pool for Process execution.
+     * Must be used in conjunction with maxForExternalTasks and maxForQueryRequests.
+     *
+     * Note that "max" and the worker-specific settings are mutually exclusive. You can only use one OR the other.
+     */
+    maxForProcessExecution?: number;
+};
+export declare type HttpClientConfig = {
+    allowUnauthorizedCertificates: boolean;
+};
+export declare type HttpServerConfig = {
+    port?: number;
+    host?: string;
+};
+export declare type IAMConfiguration = {
+    baseUrl: string;
+    clientId?: string;
+    clientSecret?: string;
+    scope?: string;
+    enableDelegationToken?: boolean;
+    minimumTokenLifetimeInMs?: number;
+    allowAnonymousRootAccess?: boolean;
+    rootAccessToken?: string;
+};
+export declare type LoggingConfiguration = {
+    minLogLevel: LogLevel;
+};
+export declare type TlsConfig = {
+    useWindowsTrustStore: boolean;
+};

package/dist/EngineEvents/EngineActions.d.ts

@@ -0,0 +1,6 @@
+export declare type EngineActions<TPayload extends Record<string, any>> = Array<EngineAction<TPayload>>;
+export declare type EngineAction<TPayload extends Record<string, any>> = ModifyTokenPayloadAction<TPayload>;
+export declare type ModifyTokenPayloadAction<TPayload extends Record<string, any>> = {
+    id: 'ModifyTokenPayload';
+    tokenPayload: TPayload;
+};

package/dist/EngineEvents/EngineEvent.d.ts

@@ -0,0 +1,71 @@
+import { RuntimeExpressionParameters } from '..';
+import { BaseElementViewModel, BpmnType } from '../ProcessModel/index';
+export declare enum LogLevel {
+    trace = "trace",
+    debug = "debug",
+    info = "info",
+    warn = "warn",
+    error = "error"
+}
+export declare type EngineEventList = {
+    logEntries: Array<EngineEvent>;
+    totalCount: number;
+};
+/**
+ * Describes an Event fired by the Engine.
+ */
+export declare type EngineEvent = {
+    eventType: EngineEventType;
+    timestamp: Date;
+    processStartedAt?: Date;
+    processFinishedAt?: Date;
+    flowNodeEnteredAt?: Date;
+    flowNodeExitedAt?: Date;
+    processModelId: string;
+    processModelName: string;
+    processDefinitionId: string;
+    processDefinitionHash: string;
+    flowNodeId?: string;
+    flowNodeInstanceId?: string;
+    flowNodeType?: BpmnType;
+    currentFlowNode?: BaseElementViewModel;
+    processInstanceId: string;
+    parentProcessInstanceId?: string;
+    correlationId: string;
+    logLevel: LogLevel;
+    tokenPayload?: object;
+    eventId?: string;
+};
+export declare type EngineEventContext = FlowNodeExpressionEngineEventContext | undefined;
+export declare type FlowNodeExpressionEngineEventContext = {
+    executeRuntimeExpression: <TExpectedResult>(expression: string, params: RuntimeExpressionParameters) => Promise<TExpectedResult>;
+    getParametersForRuntimeExpression: (expression: string, params?: RuntimeExpressionParameters) => Promise<RuntimeExpressionParameters>;
+};
+/**
+ * Contains definitions for all supported event types
+ */
+export declare enum EngineEventType {
+    OnEventProcessed = "OnEventProcessed",
+    OnProcessDeployed = "OnProcessDeployed",
+    OnProcessUndeployed = "OnProcessUndeployed",
+    OnProcessStarting = "OnProcessStarting",
+    OnProcessStarted = "OnProcessStarted",
+    OnProcessFinished = "OnProcessFinished",
+    onProcessError = "onProcessError",
+    OnProcessTerminated = "OnProcessTerminated",
+    OnProcessResumed = "OnProcessResumed",
+    OnFlowNodeEntered = "OnFlowNodeEntered",
+    OnFlowNodeCanceled = "OnFlowNodeCanceled",
+    OnFlowNodeExited = "OnFlowNodeExited",
+    OnFlowNodeSuspended = "OnFlowNodeSuspended",
+    OnFlowNodeResumed = "OnFlowNodeResumed",
+    OnFlowNodeError = "OnFlowNodeError",
+    OnFlowNodeTerminated = "OnFlowNodeTerminated",
+    OnFlowNodeCallActivityResponseReceived = "OnFlowNodeCallActivityResponseReceived",
+    OnFlowNodeEventSending = "OnFlowNodeEventSending",
+    OnFlowNodeEventRetrySending = "OnFlowNodeEventRetrySending",
+    OnFlowNodeEventResponseReceived = "OnFlowNodeEventResponseReceived",
+    OnFlowNodeTimerStarted = "OnFlowNodeTimerStarted",
+    OnFlowNodeTimerRemoved = "OnFlowNodeTimerRemoved"
+}
+export declare type CreateEngineEventRequest = EngineEvent;

package/dist/EngineEvents/EngineEventMiddlewares.d.ts

@@ -0,0 +1,7 @@
+import { EngineAction, EngineActions } from './EngineActions';
+import { EngineEvent, EngineEventContext } from './EngineEvent';
+/**
+ * Describes the Signature that a Middleware for handling Engine events should have.
+ */
+export declare type MiddlewareCallback<TPayload extends Record<string, any>> = (engineEvent: EngineEvent, context?: EngineEventContext) => Promise<EngineAction<TPayload> | EngineActions<TPayload> | void> | EngineAction<TPayload> | EngineActions<TPayload> | void;
+export declare const middlewareEventTag = "middlewareEventTag";