@5minds/processcube_engine_sdk 3.3.0

package/dist/EngineEvents/EventCallbackTypes.d.ts

@@ -0,0 +1,42 @@
+import { CronjobEventMessage, CronjobEnabledChangedMessage, EventMessage, ExternalTaskCreatedMessage, ExternalTaskExpiredMessage, ExternalTaskLockedMessage, ExternalTaskUnlockedMessage, MetadataChangedMessage, ProcessDeploymentMessage, ProcessInstancesDeletedMessage, ProcessIsExecutableChangedMessage, UserTaskFinishedMessage } from './EventPayloads/index';
+export type OnProcessDeployedCallback = (message: ProcessDeploymentMessage) => void | Promise<void>;
+export type OnProcessInstancesDeletedCallback = (message: ProcessInstancesDeletedMessage) => void | Promise<void>;
+export type OnProcessIsExecutableChangedCallback = (message: ProcessIsExecutableChangedMessage) => void | Promise<void>;
+export type OnCronjobEnabledChangedCallback = (message: CronjobEnabledChangedMessage) => void | Promise<void>;
+export type OnProcessUndeployedCallback = (message: ProcessDeploymentMessage) => void | Promise<void>;
+export type OnBoundaryEventTriggeredCallback = (boundaryEventTriggered: EventMessage) => void | Promise<void>;
+export type OnIntermediateThrowEventTriggeredCallback = (intermediateThrowEventTriggered: EventMessage) => void | Promise<void>;
+export type OnIntermediateCatchEventReachedCallback = (intermediateCatchEventReached: EventMessage) => void | Promise<void>;
+export type OnIntermediateCatchEventFinishedCallback = (intermediateCatchEventFinished: EventMessage) => void | Promise<void>;
+export type OnFlowNodeEventRetrySendingCallback = (flowNodeEventRetrySending: EventMessage) => void | Promise<void>;
+export type OnMessageTriggeredCallback = (messageTriggered: EventMessage) => void | Promise<void>;
+export type OnSignalTriggeredCallback = (signalTriggered: EventMessage) => void | Promise<void>;
+export type OnStartEventFinishedCallback = (startEventFinished: EventMessage) => void | Promise<void>;
+export type OnEndEventFinishedCallback = (endEventFinished: EventMessage) => void | Promise<void>;
+export type OnActivityReachedCallback = (activityReached: EventMessage) => void | Promise<void>;
+export type OnActivityFinishedCallback = (activityFinished: EventMessage) => void | Promise<void>;
+export type OnEmptyActivityWaitingCallback = (userTaskWaiting: EventMessage) => void | Promise<void>;
+export type OnEmptyActivityFinishedCallback = (userTaskFinished: EventMessage) => void | Promise<void>;
+export type OnManualTaskWaitingCallback = (manualTaskWaiting: EventMessage) => void | Promise<void>;
+export type OnManualTaskFinishedCallback = (manualTaskFinished: EventMessage) => void | Promise<void>;
+export type OnUserTaskWaitingCallback = (userTaskWaiting: EventMessage) => void | Promise<void>;
+export type OnUserTaskFinishedCallback = (userTaskFinished: UserTaskFinishedMessage) => void | Promise<void>;
+export type OnUserTaskReservedCallback = (userTaskWaiting: EventMessage) => void | Promise<void>;
+export type OnUserTaskReservationCanceledCallback = (userTaskFinished: UserTaskFinishedMessage) => void | Promise<void>;
+export type OnProcessStartingCallback = (processStarting: EventMessage) => void | Promise<void>;
+export type OnProcessStartedCallback = (processStarted: EventMessage) => void | Promise<void>;
+export type OnProcessErrorCallback = (processError: EventMessage) => void | Promise<void>;
+export type OnProcessEndedCallback = (processEnded: EventMessage) => void | Promise<void>;
+export type OnProcessOwnerChangedCallback = (processEnded: EventMessage) => void | Promise<void>;
+export type OnProcessTerminatedCallback = (processTerminated: EventMessage) => void | Promise<void>;
+export type OnCronjobExecutedCallback = (cronjobExecuted: CronjobEventMessage) => void | Promise<void>;
+export type OnCronjobStoppedCallback = (cronjobStopped: CronjobEventMessage) => void | Promise<void>;
+export type OnCronjobUpdatedCallback = (cronjobUpdated: CronjobEventMessage) => void | Promise<void>;
+export type OnCronjobCreatedCallback = (cronjobCreated: CronjobEventMessage) => void | Promise<void>;
+export type OnCronjobRemovedCallback = (cronjobRemoved: CronjobEventMessage) => void | Promise<void>;
+export type OnExternalTaskCreatedCallback = (externaTask: ExternalTaskCreatedMessage) => void | Promise<void>;
+export type OnExternalTaskLockedCallback = (externaTask: ExternalTaskLockedMessage) => void | Promise<void>;
+export type OnExternalTaskUnlockedCallback = (externaTask: ExternalTaskUnlockedMessage) => void | Promise<void>;
+export type OnExternalTaskExpiredCallback = (externaTask: ExternalTaskExpiredMessage) => void | Promise<void>;
+export type OnProcessInstanceMetadataChangedCallback = (metadataChanged: MetadataChangedMessage) => void | Promise<void>;
+export type OnCorrelationMetadataChangedCallback = (metadataChanged: MetadataChangedMessage) => void | Promise<void>;

package/dist/EngineEvents/EventPayloads/BaseMessage.d.ts

@@ -0,0 +1,89 @@
+import { BpmnType, EventType } from '../../ProcessModel/index';
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     EventMessage:
+ *       description: The base type for definining event messages.
+ *       type: object
+ *       required:
+ *         - correlationId
+ *         - processDefinitionId
+ *         - processModelId
+ *         - processInstanceId
+ *         - ownerId
+ *         - currentToken
+ *       properties:
+ *         correlationId:
+ *           description: The ID of the correlation that the event belongs to.
+ *           type: string
+ *         processDefinitionId:
+ *           description: The ID of the ProcessDefinition that the event belongs to.
+ *           type: string
+ *         processModelId:
+ *           description: The ID of the ProcessModel that the event belongs to.
+ *           type: string
+ *         processModelName:
+ *           description: The name of the ProcessModel that the event belongs to.
+ *           type: string
+ *         processInstanceId:
+ *           description: The ID of the ProcessInstance that the event belongs to.
+ *           type: string
+ *         parentProcessInstanceId:
+ *           description: The ID of the parent ProcessInstance (if event occured in a sub process)
+ *           type: string
+ *         flowNodeId:
+ *           description: The ID of the FlowNode that the event belongs to.
+ *           type: string
+ *         flowNodeName:
+ *           description: The name of the FlowNode that the event belongs to.
+ *           type: string
+ *         flowNodeType:
+ *           description: The BPMN type of the FlowNode that the event belongs to.
+ *           $ref: '#/components/schemas/BpmnType'
+ *         flowNodeInstanceId:
+ *           description: The ID of the FlowNodeInstance that the event belongs to.
+ *           type: string
+ *         ownerId:
+ *           description: The ID of the user that owns the ProcessInstance that the event belongs to.
+ *           type: string
+ *         previousFlowNodeInstanceId:
+ *           description: The ID of the FlowNodeInstance that was executed before.
+ *           type: string
+ *         currentToken:
+ *           description: The current token of the ProcessInstance.
+ *           type: object
+ *         eventType:
+ *           description: The type of the event.
+ *           $ref: '#/components/schemas/EventType'
+ *         eventName:
+ *           description: The name of the event.
+ *           type: string
+ *         customCorrelationId:
+ *           description: Process Instances triggered by this Message will use the following Correlation ID.
+ *           type: string
+ */
+/**
+ * The base type for definining event messages.
+ */
+export type EventMessage = {
+    correlationId: string;
+    processDefinitionId: string;
+    processModelId: string;
+    processModelName?: string;
+    processInstanceId: string;
+    parentProcessInstanceId?: string;
+    flowNodeId?: string;
+    flowNodeName?: string;
+    flowNodeType?: BpmnType;
+    flowNodeInstanceId?: string;
+    ownerId: string;
+    previousFlowNodeInstanceId?: string;
+    currentToken: any;
+    eventType?: EventType;
+    eventName?: string;
+    /**
+     * Optional: Process Instances triggered by this Message will use the following Correlation ID.
+     */
+    customCorrelationId?: string;
+};

package/dist/EngineEvents/EventPayloads/CronjobEnabledChangedMessage.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     CronjobEnabledChangedMessage:
+ *       description: Message that is sent whenever a Cronjob was enabled or disabled.
+ *       type: object
+ *       required:
+ *         - processModelId
+ *         - flowNodeId
+ *         - enabled
+ *       properties:
+ *         processModelId:
+ *           description: Contains the ID of the Process Model whose executable state was changed.
+ *           type: string
+ *         flowNodeId:
+ *           description: Contains the ID of the Cycle Start Event.
+ *           type: string
+ *         enabled:
+ *           description: The new enabled-state.
+ *           type: boolean
+ */
+/**
+ * Encapsulates the message that is sent when a Cronjob was enabled or disabled.
+ */
+export type CronjobEnabledChangedMessage = {
+    /**
+     * Contains the ID of the Process Model whose executable state was changed.
+     */
+    processModelId: string;
+    /**
+     * Contains the ID of the Cycle Start Event.
+     */
+    flowNodeId: string;
+    /**
+     * The new enabled-state.
+     */
+    enabled: boolean;
+};

package/dist/EngineEvents/EventPayloads/CronjobEvent.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     CronjobEvent:
+ *       description: Describes a single Cronjob. Used as payload for the CronjobEventMessage.
+ *       type: object
+ *       required:
+ *         - startEventId
+ *         - processModelId
+ *         - cronjob
+ *       properties:
+ *         startEventId:
+ *           description: The ID of the StartEvent that contains the cronjob.
+ *           type: string
+ *         processModelId:
+ *           description: The ID of the ProcessModel that contains the cronjob.
+ *           type: string
+ *         cronjob:
+ *           description: The crontab that describs the cronjob.
+ *           type: string
+ */
+/**
+ * Describes a single Cronjob. Used as payload for the CronjobEventMessage.
+ */
+export type CronjobEvent = {
+    startEventId: string;
+    processModelId: string;
+    cronjob: string;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     CronjobEventMessage:
+ *       description: A message that is sent when a cronjob related event was triggered.
+ *       type: object
+ *       required:
+ *         - processDefinitionId
+ *         - cronjobs
+ *       properties:
+ *         processDefinitionId:
+ *           description: The ID of the ProcessDefinition that contains the cronjob.
+ *           type: string
+ *         cronjobs:
+ *           description: The cronjobs that were triggered.
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/CronjobEvent'
+ */
+/**
+ * Encapsulates the message that is sent when a cronjob related event was triggered.
+ */
+export type CronjobEventMessage = {
+    processDefinitionId: string;
+    cronjobs: Array<CronjobEvent>;
+};

package/dist/EngineEvents/EventPayloads/ErrorEndEventReached.d.ts

@@ -0,0 +1,7 @@
+import { EventMessage } from './BaseMessage';
+/**
+ * Encapsulates the message that is sent when an Error End Event was reached.
+ */
+export type ErrorEndEventReachedMessage = EventMessage & {
+    error: Error;
+};

package/dist/EngineEvents/EventPayloads/ExternalTaskMessages.d.ts

@@ -0,0 +1,160 @@
+import { ExternalTaskReusableError } from '../../DataModels/ExternalTask/index';
+import { EventMessage } from './BaseMessage';
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ExternalTaskCreatedMessage:
+ *       description: Message that is sent whenever an ExternalTask encountered an error.
+ *       allOf:
+ *         - $ref: '#/components/schemas/EventMessage'
+ *         - type: object
+ *           required:
+ *             - externalTaskId
+ *             - topic
+ *             - isSingleTry
+ *           properties:
+ *             externalTaskId:
+ *               description: The ID of the ExternalTask.
+ *               type: string
+ *             topic:
+ *               description: The topic of the ExternalTask.
+ *               type: string
+ *             isSingleTry:
+ *               description: Flag indicating whether the ExternalTask is a SingleTry ExternalTask.
+ *               type: boolean
+ */
+/**
+ * Encapsulates the message that is sent when when an ExternalTask was created.
+ */
+export type ExternalTaskCreatedMessage = EventMessage & {
+    externalTaskId: string;
+    topic: string;
+    isSingleTry: boolean;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ExternalTaskLockedMessage:
+ *       description: Message that is sent whenever an ExternalTask was locked by a worker.
+ *       allOf:
+ *         - $ref: '#/components/schemas/ExternalTaskCreatedMessage'
+ *         - type: object
+ *           required:
+ *             - workerId
+ *             - lockExpirationTime
+ *           properties:
+ *             workerId:
+ *               description: The ID of the worker that locked the ExternalTask.
+ *               type: string
+ *             lockExpirationTime:
+ *               description: The time when the lock expires.
+ *               type: string
+ */
+/**
+ * Encapsulates the message that is sent when when a batch of ExternalTasks was locked by a worker.
+ */
+export type ExternalTaskLockedMessage = ExternalTaskCreatedMessage & {
+    workerId: string;
+    lockExpirationTime: Date;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ExternalTaskUnlockedMessage:
+ *       description: Message that is sent whenever an ExternalTask lock expires.
+ *       allOf:
+ *         - $ref: '#/components/schemas/ExternalTaskCreatedMessage'
+ *         - type: object
+ *           required:
+ *             - externalTaskId
+ *             - topic
+ *           properties:
+ *             externalTaskId:
+ *               description: The ID of the ExternalTask.
+ *               type: string
+ *             topic:
+ *               description: The topic of the ExternalTask.
+ *               type: string
+ */
+/**
+ * Encapsulates the message that is sent when when an ExternalTask lock expires.
+ * Only sent for Multi-Try External Tasks, because SingleTry External Tasks will emit an ExternalTaskExpired message in such cases.
+ */
+export type ExternalTaskUnlockedMessage = ExternalTaskCreatedMessage & {
+    externalTaskId: string;
+    topic: string;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ExternalTaskExpiredMessage:
+ *       description: Message that is sent whenever an ExternalTask expires.
+ *       allOf:
+ *         - $ref: '#/components/schemas/ExternalTaskCreatedMessage'
+ *         - type: object
+ *           required:
+ *             - externalTaskId
+ *             - topic
+ *           properties:
+ *             externalTaskId:
+ *               description: The ID of the ExternalTask.
+ *               type: string
+ *             topic:
+ *               description: The topic of the ExternalTask.
+ *               type: string
+ */
+/**
+ * Encapsulates the message that is sent when when an SingleTry ExternalTask expires.
+ */
+export type ExternalTaskExpiredMessage = ExternalTaskCreatedMessage & {
+    externalTaskId: string;
+    topic: string;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ExternalTaskErrorMessage:
+ *       description: Message that is sent whenever an ExternalTask encountered an error.
+ *       allOf:
+ *         - $ref: '#/components/schemas/ExternalTaskCreatedMessage'
+ *         - type: object
+ *           required:
+ *             - error
+ *           properties:
+ *             error:
+ *               description: The error that occurred.
+ *               $ref: '#/components/schemas/ExternalTaskReusableError'
+ */
+/**
+ * Encapsulates a payload that is used when sending an event for finishing an External Task with an error result.
+ */
+export type ExternalTaskErrorMessage = {
+    error: ExternalTaskReusableError;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ExternalTaskSuccessMessage:
+ *       description: Message that is sent whenever an ExternalTask encountered an error.
+ *       allOf:
+ *         - $ref: '#/components/schemas/ExternalTaskCreatedMessage'
+ *         - type: object
+ *           required:
+ *             - result
+ *           properties:
+ *             result:
+ *               description: The result of the ExternalTask.
+ *               type: object
+ */
+/**
+ * Encapsulates a payload that is used when sending an event for finishing an External Task with a success result.
+ */
+export type ExternalTaskSuccessMessage<TResult> = {
+    result: TResult;
+};

package/dist/EngineEvents/EventPayloads/FinishManualTask.d.ts

@@ -0,0 +1,7 @@
+import { Identity } from '../../DataModels/Iam/index';
+/**
+ * Encapsulates a payload that is used when sending an event for finishing a Manual Task.
+ */
+export type FinishManualTaskMessage = {
+    finishedBy: Identity;
+};

package/dist/EngineEvents/EventPayloads/FinishUserTask.d.ts

@@ -0,0 +1,9 @@
+import { UserTaskResult } from '../../DataModels/FlowNodeInstance/index';
+import { Identity } from '../../DataModels/Iam/index';
+/**
+ * Encapsulates a payload that is used when sending an event for finishing a User Task.
+ */
+export type FinishUserTaskMessage = {
+    finishedBy: Identity;
+    userTaskResult: UserTaskResult;
+};

package/dist/EngineEvents/EventPayloads/MessageEventReached.d.ts

@@ -0,0 +1,13 @@
+import { Identity } from '../../DataModels/Iam/index';
+import { EventMessage } from './BaseMessage';
+/**
+ * Encapsulates the message that is sent when a Message Event was triggered.
+ */
+export type MessageEventReachedMessage = EventMessage & {
+    /**
+     * Optional: An identity to use for starting new Processes Instances with a matching Message Start Event.
+     * If none is providecd, the engine will use its internal user.
+     */
+    identity?: Identity;
+    messageReference: string;
+};

package/dist/EngineEvents/EventPayloads/MetadataChangedMessage.d.ts

@@ -0,0 +1,25 @@
+import { EventMessage } from './BaseMessage';
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     MetadataChangedMessage:
+ *       description: Message that is sent whenever the metadata of a Correlation or Process Instance was changed by a Flow Node Instance.
+ *       allOf:
+ *         - $ref: '#/components/schemas/EventMessage'
+ *         - type: object
+ *           properties:
+ *             changedMetadata:
+ *               description: The changed metadata.
+ *               type: object
+ *               additionalProperties:
+ *                 type: string
+ */
+/**
+ * Encapsulates a message for when the metadata of a Correlation or Process Instance was changed by a Flow Node Instance.
+ */
+export type MetadataChangedMessage = EventMessage & {
+    changedMetadata: {
+        [key: string]: string;
+    };
+};

package/dist/EngineEvents/EventPayloads/ProcessDeploymentMessage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessDeploymentMessage:
+ *       description: Message that is sent whenever a Process was deployed or undeployed.
+ *       type: object
+ *       required:
+ *         - processDefinitionId
+ *       properties:
+ *         processDefinitionId:
+ *           description: The ID or the list of IDs of the deployed/undeployed process(es).
+ *           oneOf:
+ *             - type: string
+ *             - type: array
+ *               items:
+ *                 type: string
+ */
+/**
+ * Encapsulates the message that is sent when a Process was deployed or undeployed.
+ */
+export type ProcessDeploymentMessage = {
+    /**
+     * Contains the ID or the list of IDs of the deployed/undeployed process(es).
+     */
+    processDefinitionId: string | Array<string>;
+};

package/dist/EngineEvents/EventPayloads/ProcessInstancesDeletedMessage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Encapsulates the message that is sent when a set of Process Instances was deleted.
+ */
+export type ProcessInstancesDeletedMessage = {
+    /**
+     * Contains the IDs of the deleted process instances.
+     */
+    processInstanceIds: Array<string>;
+};

package/dist/EngineEvents/EventPayloads/ProcessIsExecutableChangedMessage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessIsExecutableChangedMessage:
+ *       description: The message that is sent whenever a Process was flagged as executable or not executable.
+ *       type: object
+ *       required:
+ *         - processModelId
+ *         - isExecutable
+ *       properties:
+ *         processModelId:
+ *           description: Contains the ID of the Process Model whose executable state was changed.
+ *           type: string
+ *         isExecutable:
+ *           description: Contains the new state of the isExecutable flag.
+ *           type: boolean
+ */
+/**
+ * Encapsulates the message that is sent when a Process was flagged as executable or not executable.
+ */
+export type ProcessIsExecutableChangedMessage = {
+    /**
+     * Contains the ID of the Process Model whose executable state was changed.
+     */
+    processModelId: string;
+    /**
+     * Contains the new state of the isExecutable flag.
+     */
+    isExecutable: boolean;
+};

package/dist/EngineEvents/EventPayloads/SignalEventReached.d.ts

@@ -0,0 +1,13 @@
+import { Identity } from '../../DataModels/Iam/index';
+import { EventMessage } from './BaseMessage';
+/**
+ * Encapsulates the message that is sent when a Signal Event was triggered.
+ */
+export type SignalEventReachedMessage = EventMessage & {
+    /**
+     * Optional: An identity to use for starting new Processes Instances with a matching Signal Start Event.
+     * If none is providecd, the engine will use its internal user.
+     */
+    identity?: Identity;
+    signalReference: string;
+};

package/dist/EngineEvents/EventPayloads/TerminateProcessInstance.d.ts

@@ -0,0 +1,18 @@
+import { Identity } from '../../DataModels/Iam/index';
+/**
+ * Encapsulates a message for when a Process Instance gets terminated.
+ */
+export type TerminateProcessInstanceMessage = {
+    /**
+     * If the Process Instance is terminated by a user, this will contain the users identity.
+     */
+    terminatedBy?: Identity;
+    /**
+     * If the Process Instance is terminated by a Terminate End Event, this will contain the End Events FlowNodeId.
+     */
+    flowNodeId?: string;
+    /**
+     * If the Process Instance is terminated by a Terminate End Event, this will contain the End Events current token payload.
+     */
+    currentToken?: any;
+};

package/dist/EngineEvents/EventPayloads/TokenChangeMessage.d.ts

@@ -0,0 +1,10 @@
+import { EngineEventType } from '../EngineEvent';
+/**
+ * Encapsulates a message for changing the token payload of a FlowNodeInstance,
+ * after a corresponding action was triggered by an Event Middleware.
+ */
+export type TokenChangeMessage = {
+    eventType: EngineEventType;
+    flowNodeInstanceId: string;
+    tokenPayload: any;
+};

package/dist/EngineEvents/EventPayloads/UserTaskFinished.d.ts

@@ -0,0 +1,8 @@
+import { UserTaskResult } from '../../DataModels/FlowNodeInstance/index';
+import { EventMessage } from './BaseMessage';
+/**
+ * Encapsulates the message that is sent when a User Task has been finished.
+ */
+export type UserTaskFinishedMessage = EventMessage & {
+    userTaskResult: UserTaskResult;
+};

package/dist/EngineEvents/EventPayloads/index.d.ts

@@ -0,0 +1,16 @@
+export * from './BaseMessage';
+export * from './CronjobEvent';
+export * from './CronjobEnabledChangedMessage';
+export * from './ErrorEndEventReached';
+export * from './ExternalTaskMessages';
+export * from './FinishManualTask';
+export * from './FinishUserTask';
+export * from './MessageEventReached';
+export * from './MetadataChangedMessage';
+export * from './ProcessDeploymentMessage';
+export * from './ProcessInstancesDeletedMessage';
+export * from './ProcessIsExecutableChangedMessage';
+export * from './SignalEventReached';
+export * from './UserTaskFinished';
+export * from './TerminateProcessInstance';
+export * from './TokenChangeMessage';

package/dist/EngineEvents/IConstructor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This is a helper interface, which will allow us to create instances for
+ * FlowNodes from generic functions.
+ */
+export type IConstructor<TModule> = new (...args: Array<any>) => TModule;

package/dist/EngineEvents/Subscription.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Defines the signature for the Callback that an EventSubscription should have.
+ *
+ * @param eventPayload Optional: The payload received with the event.
+ * @param eventName    Optional: The name of the received event.
+ */
+export declare type EventReceivedCallback = (eventPayload?: any, eventName?: string) => void | Promise<void>;
+/**
+ * Contains information about a subscription on the EventAggregator.
+ * External services can use this information to manage their own subscriptions.
+ */
+export declare type Subscription = {
+    /**
+     * The Id under which the EventAggregator has stored the Subscription.
+     */
+    readonly id: string;
+    /**
+     * The name of the event for which the Subscription was created.
+     */
+    readonly eventName: string;
+    /**
+     * If set to true, the Subscription will be destroyed after first receiving
+     * the event.
+     */
+    readonly onlyReceiveOnce: boolean;
+};

package/dist/EngineEvents/index.d.ts

@@ -0,0 +1,20 @@
+export * from './EngineActions';
+export * from './EventCallbackTypes';
+export * from './EngineEvent';
+export * from './EngineEventMiddlewares';
+export * from './EventPayloads/index';
+export * from './Subscription';
+/**
+ * Only for backwards compatibility.
+ * We'd get a ton of breaking changes without them, when using the SDK with the client or proxy.
+ */
+import * as eventPayloads from './EventPayloads/index';
+import * as callbackTypes from './EventCallbackTypes';
+import * as iConstructor from './IConstructor';
+export declare namespace Messages {
+    export import EventMessage = eventPayloads.EventMessage;
+    export import IConstructor = iConstructor.IConstructor;
+    export import BpmnEvents = eventPayloads;
+    export import SystemEvents = eventPayloads;
+    export import CallbackTypes = callbackTypes;
+}