@5minds/processcube_engine_sdk 5.0.0-alpha.3 → 5.0.0-alpha.5

package/dist/EngineEvents/EventCallbackTypes.d.ts

@@ -5,6 +5,7 @@ export type OnProcessInstancesDeletedCallback = (message: ProcessInstancesDelete
 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 OnBoundaryEventWaitingCallback = (boundaryEventWaiting: EventMessage) => void | Promise<void>;
 export type OnBoundaryEventTriggeredCallback = (boundaryEventTriggered: EventMessage) => void | Promise<void>;
 export type OnBoundaryEventFinishedCallback = (boundaryEventFinished: EventMessage) => void | Promise<void>;
 export type OnIntermediateThrowEventTriggeredCallback = (intermediateThrowEventTriggered: EventMessage) => void | Promise<void>;

package/dist/EngineEvents/index.d.ts

@@ -6,7 +6,6 @@ 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';

package/dist/ExtensionAdapter/NotificationExtensionAdapter.d.ts

@@ -113,6 +113,10 @@ export interface INotificationExtensionAdapter {
         subscribeOnce?: boolean;
         identity?: Identity;
     }): Promise<Subscription>;
+    onBoundaryEventWaiting(callback: Messages.CallbackTypes.OnBoundaryEventWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
     onBoundaryEventTriggered(callback: Messages.CallbackTypes.OnBoundaryEventTriggeredCallback, options?: {
         subscribeOnce?: boolean;
         identity?: Identity;

package/dist/ProcessModel/Model/Activities/ActivityBase.d.ts

@@ -1,6 +1,27 @@
 import { FlowNode } from '../Base/index';
+export declare enum LoopMarker {
+    Loop = "Loop",
+    Parallel = "Parallel",
+    Sequential = "Sequential"
+}
 /**
- * The base class for all activities.
+ * The base for all Activities.
  */
-export declare abstract class Activity extends FlowNode {
-}
+export type Activity = FlowNode & {
+    /**
+     * A marker configuring a FlowNode to run multiple times.
+     */
+    loopMarker?: LoopMarker;
+    /**
+     * A condition, which is evaluated at the end of a FlowNode with a Loop Marker to determine, if it should break.
+     */
+    loopInstanceBreakCondition?: string;
+    /**
+     * Contains an expression that has to result in a number value describing the amount of time to wait between loop iterations in ms
+     */
+    timeoutBetweenLoopIterations?: string;
+    /**
+     * Contains an expression that has to result in a number value describing the maximum amount of allowed iterations. If exceeded an error will be thrown
+     */
+    maxLoopIterations?: string;
+};

package/dist/ProcessModel/Model/Activities/BusinessRuleTask.d.ts

@@ -5,8 +5,8 @@ import { Activity } from './ActivityBase';
  *
  * Note that the engine does not yet support these!
  */
-export declare class BusinessRuleTask extends Activity {
-    get bpmnType(): BpmnType;
+export type BusinessRuleTask = Activity & {
+    readonly bpmnType: BpmnType.businessRuleTask;
     /**
      * The topic to use in conjunction with external ServiceTasks.
      */
@@ -22,4 +22,4 @@ export declare class BusinessRuleTask extends Activity {
     decisionRef: string;
     decisionRefBinding: string;
     decisionRefVersion: string;
-}
+};

package/dist/ProcessModel/Model/Activities/CallActivity.d.ts

@@ -9,10 +9,9 @@ import { Activity } from './ActivityBase';
  * This means that the process called by the CallActivity can also run by itself,
  * unlike the subprocess contained within the 'SubProcess' Activity.
  */
-export declare class CallActivity extends Activity {
-    get bpmnType(): BpmnType;
-    type: CallActivityType;
-    calledReference?: string;
+export type CallActivity = Activity & {
+    readonly bpmnType: BpmnType.callActivity;
+    targetProcessModelId?: string;
     /**
      * Optional: The ID of the StartEvent with which to call the CallActivity.
      * If no ID is provided, the first found StartEventID is used.
@@ -23,34 +22,5 @@ export declare class CallActivity extends Activity {
      * If not provided, the current token is used as a payload.
      */
     payload?: any;
-    bindingType: CallActivityBindingType;
     calledElementVersion?: string;
-    calledElementTenantId: string;
-    delegateVariableMapping: CallActivityDelegateVariableMapping;
-    variableMappingValue?: string;
-}
-/**
- * Contains all types of CallActivities.
- * Currently only 'BPMN' is supported.
- */
-export declare enum CallActivityType {
-    Unspecified = 0,
-    BPMN = 1
-}
-/**
- * Contains all possible types of binding that can be used with a CallActivity.
- */
-export declare enum CallActivityBindingType {
-    latest = 0,
-    deployment = 1,
-    version = 2
-}
-/**
- * Determines the type of mapping used by the CallActivity, when passing on its
- * parameters to the called process.
- */
-export declare enum CallActivityDelegateVariableMapping {
-    Unspecified = 0,
-    variableMappingClass = 1,
-    variableMappingDelegateExpression = 2
-}
+};

package/dist/ProcessModel/Model/Activities/ManualTask.d.ts

@@ -2,10 +2,11 @@ import { BpmnType } from '../Constants';
 import { Activity } from './ActivityBase';
 /**
  * Describes a BPMN ManualTask.
- *
- * Currently not evaluated during runtime.
  */
-export declare class ManualTask extends Activity {
-    get bpmnType(): BpmnType;
+export type ManualTask = Activity & {
+    readonly bpmnType: BpmnType.manualTask;
+    /**
+     * If set to false, the Manual Task will automatically finish, without waiting for User input.
+     */
     requiresConfirmation: boolean;
-}
+};

package/dist/ProcessModel/Model/Activities/ReceiveTask.d.ts

@@ -7,9 +7,9 @@ import { Activity } from './ActivityBase';
  * A ReceiveTask is used to wait for a message send by a SendTask.
  * Works the same as the IntermediateMessageCatchEvent.
  */
-export declare class ReceiveTask extends Activity {
-    get bpmnType(): BpmnType;
-    get eventType(): EventType;
+export type ReceiveTask = Activity & {
+    readonly bpmnType: BpmnType.receiveTask;
+    readonly eventType: EventType;
     /**
      * This is the user defined Message which is expected by this ReceiveTask.
      */
@@ -22,4 +22,4 @@ export declare class ReceiveTask extends Activity {
      * Optional: If set, the Receive Task will only continue, if the given expression results into a value, which matches the value from triggerValueInToken.
      */
     triggerValueInEventPayload?: string;
-}
+};

package/dist/ProcessModel/Model/Activities/ScriptTask.d.ts

@@ -5,9 +5,7 @@ import { Activity } from './ActivityBase';
  *
  * This type of task is used to execute JS code snippets.
  */
-export declare class ScriptTask extends Activity {
-    get bpmnType(): BpmnType;
-    scriptFormat: string;
+export type ScriptTask = Activity & {
+    readonly bpmnType: BpmnType.scriptTask;
     script: string;
-    resultVariable: string;
-}
+};

package/dist/ProcessModel/Model/Activities/SendTask.d.ts

@@ -7,9 +7,9 @@ import { Activity } from './ActivityBase';
  * A SendTask sends a message.
  * Works the same as the IntermediateMessageThrowEvent.
  */
-export declare class SendTask extends Activity {
-    get bpmnType(): BpmnType;
-    get eventType(): EventType;
+export type SendTask = Activity & {
+    readonly bpmnType: BpmnType.sendTask;
+    readonly eventType: EventType;
     /**
      * The message that should be send.
     ‚ */
@@ -24,4 +24,4 @@ export declare class SendTask extends Activity {
      * If not provided, the current token is used as a payload.
      */
     payload?: any;
-}
+};

package/dist/ProcessModel/Model/Activities/ServiceTask.d.ts

@@ -2,15 +2,14 @@ import { BpmnType } from '../Constants';
 import { Activity } from './ActivityBase';
 /**
  * Describes a BPMN ServiceTask.
- * A ServiceTask is used to call either a function from a specific class,
- * or for performing web requests.
+ * A ServiceTask is used to delegate a BPMN Task to an external system.
  */
-export declare class ServiceTask extends Activity {
-    get bpmnType(): BpmnType;
+export type ServiceTask = Activity & {
+    readonly bpmnType: BpmnType.serviceTask;
     /**
-     * The invocation to be used when the ServiceTask is called.
+     * The invocation to be used when a custom ServiceTask is used.
      */
-    invocation: Invocation;
+    invocation?: MethodInvocation;
     /**
      * The ServiceTasks type.
      * Currently only supports 'external' and 'internal'.
@@ -32,7 +31,7 @@ export declare class ServiceTask extends Activity {
      * The type of ServiceTask. Determines how the ServiceTask is processed.
      */
     customType?: string;
-}
+};
 /**
  * Describes all currently supported ServiceTask types.
  */
@@ -41,16 +40,11 @@ export declare enum ServiceTaskType {
     internal = "internal"
 }
 /**
- * The base class for all invocation types.
- */
-export declare abstract class Invocation {
-}
-/**
- * Used by ServiceTasks.
+ * Used by Custom ServiceTasks.
  * This contains the definition for a method invocation.
  */
-export declare class MethodInvocation extends Invocation {
+export type MethodInvocation = {
     module: string;
     method: string;
     params: string;
-}
+};

package/dist/ProcessModel/Model/Activities/SubProcess.d.ts

@@ -8,8 +8,8 @@ import { Activity } from './ActivityBase';
  * Technically they work like normal processes, except that they exist only
  * within another process and are treated like an activity for that process.
  */
-export declare class SubProcess extends Activity {
-    get bpmnType(): BpmnType;
+export type SubProcess = Activity & {
+    readonly bpmnType: BpmnType.subProcess;
     laneSet?: LaneSet;
     flowNodes: Array<FlowNode>;
     sequenceFlows: Array<SequenceFlow>;
@@ -17,4 +17,4 @@ export declare class SubProcess extends Activity {
     dataStoreReferences: Array<DataStoreReference>;
     dataObjectReferences: Array<DataObjectReference>;
     dataObjects: Array<DataObject>;
-}
+};

package/dist/ProcessModel/Model/Activities/UntypedTask.d.ts

@@ -1,11 +1,9 @@
 import { BpmnType } from '../Constants';
-import { FlowNode } from '../Base/index';
+import { Activity } from './ActivityBase';
 /**
  * Contains a task without any type definition.
- *
- * Technically, this services as a Breakpoint for the Frontend.
  */
-export declare class UntypedTask extends FlowNode {
-    get bpmnType(): BpmnType;
+export type UntypedTask = Activity & {
+    readonly bpmnType: BpmnType.untypedTask;
     enabled: boolean;
-}
+};

package/dist/ProcessModel/Model/Activities/UserTask.d.ts

@@ -6,8 +6,8 @@ import { Activity } from './ActivityBase';
  * A user task will hold the current execution of the process and wait for user input
  * before continuing.
  */
-export declare class UserTask extends Activity {
-    get bpmnType(): BpmnType;
+export type UserTask = Activity & {
+    readonly bpmnType: BpmnType.userTask;
     customForm?: string;
     assignee: string;
     candidateUsers: string;
@@ -18,14 +18,14 @@ export declare class UserTask extends Activity {
     formFields: Array<UserTaskFormField>;
     description: string;
     finishedMessage: string;
-}
+};
 /**
  * Describes a BPMN FormField.
  * A FormField is part of a UserTask and can contain all kinds of values.
  *
  * These values can then be used to finish the UserTask.
  */
-export declare class UserTaskFormField {
+export type UserTaskFormField = {
     /**
      * The UserTasks unique identifier.
      */
@@ -56,12 +56,12 @@ export declare class UserTaskFormField {
      * something similar.
      */
     customForm?: string;
-}
+};
 /**
  * Used in combination with 'enum' type UserTask FormFields,
  * this describes a single enum value of that FormField.
  */
-export declare class FormFieldEnumValue {
+export type FormFieldEnumValue = {
     id: string;
     name: string;
-}
+};

package/dist/ProcessModel/Model/Activities/index.d.ts

@@ -12,7 +12,6 @@ export * from './SubProcess';
 export * from './UntypedTask';
 export * from './UserTask';
 export declare namespace Invocations {
-    export import Invocation = serviceTaskInvocations.Invocation;
     export import MethodInvocation = serviceTaskInvocations.MethodInvocation;
 }
 export declare namespace Types {

package/dist/ProcessModel/Model/Base/BaseElement.d.ts

@@ -1,9 +1,9 @@
 import { ExtensionElements } from './ExtensionElements';
 /**
- * The base class for all BPMN elements, including processes, participants, etc.
+ * The base for all BPMN elements, including Processes, Participants, Flow Nodes, etc.
  */
-export declare abstract class BaseElement {
+export type BaseElement = {
     id: string;
     documentation?: Array<string>;
     extensionElements?: ExtensionElements;
-}
+};

package/dist/ProcessModel/Model/Base/DataInputAssociation.d.ts

@@ -3,7 +3,7 @@ import { BaseElement } from './BaseElement';
  * Contains a BPMN DataInputAssociation.
  * These associations signify that a FlowNode requires data from a DataObject or DataStore.
  */
-export declare class DataInputAssociation extends BaseElement {
+export type DataInputAssociation = BaseElement & {
     /**
      * The given name of the DataInputAssociation.
      */
@@ -16,4 +16,4 @@ export declare class DataInputAssociation extends BaseElement {
      * The ID of the FlowNode that requires data from the DataObject or DataStore.
      */
     targetRef: string;
-}
+};

package/dist/ProcessModel/Model/Base/DataOutputAssociation.d.ts

@@ -3,7 +3,7 @@ import { BaseElement } from './BaseElement';
  * Contains a BPMN DataOutputAssociation.
  * These associations signify that a FlowNode writes data into a DataObject or DataStore.
  */
-export declare class DataOutputAssociation extends BaseElement {
+export type DataOutputAssociation = BaseElement & {
     /**
      * The given name of the DataOutputAssociation.
      */
@@ -20,4 +20,4 @@ export declare class DataOutputAssociation extends BaseElement {
      * Contains an expression that describes the data to write to the DataObject/DataStore referenced in targetRef.
      */
     dataSource: string;
-}
+};

package/dist/ProcessModel/Model/Base/ExtensionElements.d.ts

@@ -1,12 +1,18 @@
-import { CamundaExecutionListener } from './CamundaExecutionListener';
-import { CamundaExtensionProperty } from './CamundaExtensionProperty';
-/**
- * This wraps all camunda specific properties and elements that can be
- * associated with any BPMN element.
- * For example, for ServiceTasks, these will store the properties
- * 'module', 'method' and 'params'.
- */
-export declare class ExtensionElements {
+export type CamundaExecutionListener = {
+    class: any;
+    event: any;
+};
+export type CamundaExtensionProperty = {
+    name: string;
+    value: string;
+};
+export type SignavioMetadata = {
+    metaKey: string;
+    metaValue: string;
+};
+export type ExtensionElements = {
     camundaExecutionListener?: CamundaExecutionListener;
     camundaExtensionProperties?: Array<CamundaExtensionProperty>;
-}
+    signavioLabel?: Record<string, any>;
+    signavioMetaData?: Array<SignavioMetadata>;
+};

package/dist/ProcessModel/Model/Base/FlowNode.d.ts

@@ -1,12 +1,12 @@
 import { BpmnType } from '../Constants';
 import { BaseElement, DataInputAssociation, DataOutputAssociation } from '.';
 /**
- * Base class for all FlowNodes.
+ * Base for all FlowNodes.
  * These include Events, Gateways and Activities.
  */
-export declare abstract class FlowNode extends BaseElement {
+export type FlowNode = BaseElement & {
+    readonly bpmnType: BpmnType;
     name: string;
-    defaultOutgoingSequenceFlowId?: string;
     /**
      * A list of all incoming sequence flow IDs.
      */
@@ -19,12 +19,12 @@ export declare abstract class FlowNode extends BaseElement {
      * A list of all DataInputAssociations.
      * DataInputAssociations point to a DataStore or DataSource that the FlowNode requires data from.
      */
-    dataInputAssociations: Array<DataInputAssociation>;
+    dataInputAssociations?: Array<DataInputAssociation>;
     /**
      * A list of all DataOutputAssociations.
      * DataOutputAssociations point to a DataStore or DataSource that the FlowNode will write to after finishing
      */
-    dataOutputAssociations: Array<DataOutputAssociation>;
+    dataOutputAssociations?: Array<DataOutputAssociation>;
     /**
      * The script that is run before the FlowNode starts execution.
      */
@@ -33,26 +33,4 @@ export declare abstract class FlowNode extends BaseElement {
      * The script that is run after the FlowNode has finished execution.
      */
     postScript?: string;
-    /**
-     * A marker configuring a FlowNode to run multiple times.
-     */
-    loopMarker?: LoopMarker;
-    /**
-     * A condition, which is evaluated at the end of a FlowNode with a Loop Marker to determine, if it should break.
-     */
-    loopInstanceBreakCondition?: string;
-    /**
-     * Contains an expression that has to result in a number value describing the amount of time to wait between loop iterations in ms
-     */
-    timeoutBetweenLoopIterations?: string;
-    /**
-     * Contains an expression that has to result in a number value describing the maximum amount of allowed iterations. If exceeded an error will be thrown
-     */
-    maxLoopIterations?: string;
-    abstract readonly bpmnType: BpmnType;
-}
-export declare enum LoopMarker {
-    Loop = 0,
-    Parallel = 1,
-    Sequential = 2
-}
+};

package/dist/ProcessModel/Model/Base/index.d.ts

@@ -1,15 +1,9 @@
-import * as cel from './CamundaExecutionListener';
-import * as cep from './CamundaExtensionProperty';
 import * as ee from './ExtensionElements';
 export * from './BaseElement';
-export * from './CamundaExecutionListener';
-export * from './CamundaExtensionProperty';
 export * from './DataInputAssociation';
 export * from './DataOutputAssociation';
 export * from './ExtensionElements';
 export * from './FlowNode';
 export declare namespace Types {
-    export import CamundaExecutionListener = cel.CamundaExecutionListener;
-    export import CamundaExtensionProperty = cep.CamundaExtensionProperty;
     export import ExtensionElements = ee.ExtensionElements;
 }

package/dist/ProcessModel/Model/BpmnComponentTags.d.ts

@@ -93,7 +93,9 @@ export declare enum TaskElement {
  * Contains all BPMN tags that a BPMN element can have.
  */
 export declare enum FlowElementProperty {
+    ConditionalEventDefinition = "conditionalEventDefinition",
     ErrorEventDefinition = "errorEventDefinition",
+    EscalationEventDefinition = "escalationEventDefinition",
     LinkEventDefinition = "linkEventDefinition",
     MessageEventDefinition = "messageEventDefinition",
     SignalEventDefinition = "signalEventDefinition",
@@ -135,6 +137,10 @@ export declare enum CamundaProperty {
     VariableMappingDelegateExpression = "camunda:variableMappingDelegateExpression",
     ErrorMessageVariable = "camunda:errorMessageVariable"
 }
+export declare enum SignavioProperty {
+    signavioLabel = "signavio:signavioLabel",
+    signavioMetaData = "signavio:signavioMetaData"
+}
 /**
  * Contains the loop and multi instance markers.
  */

package/dist/ProcessModel/Model/Collaboration.d.ts

@@ -1,12 +1,12 @@
 import { BaseElement } from './Base/index';
-import { MessageFlow } from './GlobalElements/MessageFlow';
 import { Participant } from './Participant';
+import { MessageFlow } from './ProcessElements/MessageFlow';
 /**
  * Contains information about the BPMN collaboration, such as the name of the
  * collaboration and a list of participants.
  */
-export declare class Collaboration extends BaseElement {
+export type Collaboration = BaseElement & {
     name: string;
     participants: Array<Participant>;
     messageFlows: Array<MessageFlow>;
-}
+};

package/dist/ProcessModel/Model/Constants.d.ts

@@ -60,21 +60,25 @@ export declare enum BpmnType {
  *       description: The type of an event.
  *       type: string
  *       enum:
+ *         - conditionalEvent
+ *         - errorEvent
+ *         - escalationEvent
  *         - linkEvent
  *         - messageEvent
  *         - signalEvent
  *         - terminateEvent
  *         - timerEvent
- *         - errorEvent
  */
 /**
  * Contains a list of all supported event types.
  */
 export declare enum EventType {
+    conditionalEvent = "conditionalEvent",
+    errorEvent = "errorEvent",
+    escalationEvent = "escalationEvent",
     linkEvent = "linkEvent",
     messageEvent = "messageEvent",
     signalEvent = "signalEvent",
     terminateEvent = "terminateEvent",
-    timerEvent = "timerEvent",
-    errorEvent = "errorEvent"
+    timerEvent = "timerEvent"
 }

package/dist/ProcessModel/Model/Definitions.d.ts

@@ -1,4 +1,4 @@
-import { BaseElement, FlowNode } from './Base/index';
+import { BaseElement, ExtensionElements, FlowNode } from './Base/index';
 import { Collaboration } from './Collaboration';
 import { EndEvent, StartEvent } from './Events/index';
 import { Process } from './Process';
@@ -8,7 +8,7 @@ import { BpmnType } from './Constants';
  * Contains the parsed ProcessModels, taken from a BPMN file.
  * This is the root object for the internal ProcessModel structure.
  */
-export declare class Definitions extends BaseElement {
+export declare class Definitions implements BaseElement {
     id: string;
     displayName: string;
     /**
@@ -41,6 +41,8 @@ export declare class Definitions extends BaseElement {
      * Contains a list of all processes contained within this definition.
      */
     processes: Array<Process>;
+    documentation?: Array<string>;
+    extensionElements?: ExtensionElements;
     /**
      * Gets a list of all StartEvents contained in this ProcessDefinition.
      */

package/dist/ProcessModel/Model/Events/ConditionalEvents.d.ts

@@ -0,0 +1,17 @@
+import { EventType } from '../Constants';
+import { BoundaryEvent, Event, EventDefinition, IntermediateCatchEvent } from './EventBase';
+/**
+ * The parameters required to configure a ConditionalEvent.
+ */
+export type ConditionalEventDefinition = EventDefinition & {
+    condition: string;
+};
+/**
+ * Describes a Flow Node with a Conditional Event Definition.
+ */
+export type ConditionalEvent = Event & {
+    readonly eventType: EventType.conditionalEvent;
+    conditionalEventDefinition: ConditionalEventDefinition;
+};
+export type ConditionalBoundaryEvent = BoundaryEvent & ConditionalEvent;
+export type ConditionalIntermediateCatchEvent = IntermediateCatchEvent & ConditionalEvent;

package/dist/ProcessModel/Model/Events/ErrorEvents.d.ts

@@ -0,0 +1,28 @@
+import { BaseElement } from '../Base/BaseElement';
+import { EventType } from '../Constants';
+import { BoundaryEvent, Event, EndEvent, EventDefinition } from './EventBase';
+/**
+ * Describes a BPMN error used by Error End Events and Error Boundary Events.
+ */
+export type Error = BaseElement & {
+    name?: string;
+    code?: string;
+    message?: string;
+};
+/**
+ * Contains the definition for an ErrorEvent.
+ */
+export type ErrorEventDefinition = EventDefinition & {
+    name?: string;
+    code?: string;
+    message?: string;
+};
+/**
+ * Describes a Flow Node with an Error Event Definition.
+ */
+export type ErrorEvent = Event & {
+    readonly eventType: EventType.errorEvent;
+    errorEventDefinition: ErrorEventDefinition;
+};
+export type ErrorBoundaryEvent = BoundaryEvent & ErrorEvent;
+export type ErrorEndEvent = EndEvent & ErrorEvent;