@5minds/processcube_engine_sdk 5.0.0-feature-83e66e-lpv6jsi3 → 5.0.0-feature-e8bbf3-lpv7j85k

package/dist/EngineEvents/index.d.ts

@@ -6,6 +6,7 @@ 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/ProcessModel/Model/Activities/ActivityBase.d.ts

@@ -1,27 +1,6 @@
 import { FlowNode } from '../Base/index';
-export declare enum LoopMarker {
-    Loop = "Loop",
-    Parallel = "Parallel",
-    Sequential = "Sequential"
-}
 /**
- * The base for all Activities.
+ * The base class for all activities.
  */
-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;
-    /**
-     * If set, waits a timeout between loop iterations before starting the next loop in ms
-     */
-    timeoutBetweenLoopIterations?: number;
-    /**
-     * If set, throws an error, if the maximum number of iterations is exceeded
-     */
-    maxLoopIterations?: number;
-};
+export declare abstract class Activity extends FlowNode {
+}

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 type BusinessRuleTask = Activity & {
-    readonly bpmnType: BpmnType.businessRuleTask;
+export declare class BusinessRuleTask extends Activity {
+    get bpmnType(): BpmnType;
     /**
      * The topic to use in conjunction with external ServiceTasks.
      */
@@ -22,4 +22,4 @@ export type BusinessRuleTask = Activity & {
     decisionRef: string;
     decisionRefBinding: string;
     decisionRefVersion: string;
-};
+}

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

@@ -9,9 +9,10 @@ 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 type CallActivity = Activity & {
-    readonly bpmnType: BpmnType.callActivity;
-    targetProcessModelId?: string;
+export declare class CallActivity extends Activity {
+    get bpmnType(): BpmnType;
+    type: CallActivityType;
+    calledReference?: string;
     /**
      * Optional: The ID of the StartEvent with which to call the CallActivity.
      * If no ID is provided, the first found StartEventID is used.
@@ -22,5 +23,34 @@ export type CallActivity = 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,11 +2,10 @@ import { BpmnType } from '../Constants';
 import { Activity } from './ActivityBase';
 /**
  * Describes a BPMN ManualTask.
+ *
+ * Currently not evaluated during runtime.
  */
-export type ManualTask = Activity & {
-    readonly bpmnType: BpmnType.manualTask;
-    /**
-     * If set to false, the Manual Task will automatically finish, without waiting for User input.
-     */
+export declare class ManualTask extends Activity {
+    get bpmnType(): BpmnType;
     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 type ReceiveTask = Activity & {
-    readonly bpmnType: BpmnType.receiveTask;
-    readonly eventType: EventType;
+export declare class ReceiveTask extends Activity {
+    get bpmnType(): BpmnType;
+    get eventType(): EventType;
     /**
      * This is the user defined Message which is expected by this ReceiveTask.
      */
@@ -22,4 +22,4 @@ export type ReceiveTask = 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,7 +5,9 @@ import { Activity } from './ActivityBase';
  *
  * This type of task is used to execute JS code snippets.
  */
-export type ScriptTask = Activity & {
-    readonly bpmnType: BpmnType.scriptTask;
+export declare class ScriptTask extends Activity {
+    get bpmnType(): BpmnType;
+    scriptFormat: string;
     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 type SendTask = Activity & {
-    readonly bpmnType: BpmnType.sendTask;
-    readonly eventType: EventType;
+export declare class SendTask extends Activity {
+    get bpmnType(): BpmnType;
+    get eventType(): EventType;
     /**
      * The message that should be send.
     ‚ */
@@ -24,4 +24,4 @@ export type SendTask = Activity & {
      * If not provided, the current token is used as a payload.
      */
     payload?: any;
-};
+}

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

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

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

@@ -1,9 +1,11 @@
 import { BpmnType } from '../Constants';
-import { Activity } from './ActivityBase';
+import { FlowNode } from '../Base/index';
 /**
  * Contains a task without any type definition.
+ *
+ * Technically, this services as a Breakpoint for the Frontend.
  */
-export type UntypedTask = Activity & {
-    readonly bpmnType: BpmnType.untypedTask;
+export declare class UntypedTask extends FlowNode {
+    get bpmnType(): BpmnType;
     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 type UserTask = Activity & {
-    readonly bpmnType: BpmnType.userTask;
+export declare class UserTask extends Activity {
+    get bpmnType(): BpmnType;
     customForm?: string;
     assignee: string;
     candidateUsers: string;
@@ -18,14 +18,14 @@ export type UserTask = 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 type UserTaskFormField = {
+export declare class UserTaskFormField {
     /**
      * The UserTasks unique identifier.
      */
@@ -56,12 +56,12 @@ export type UserTaskFormField = {
      * something similar.
      */
     customForm?: string;
-};
+}
 /**
  * Used in combination with 'enum' type UserTask FormFields,
  * this describes a single enum value of that FormField.
  */
-export type FormFieldEnumValue = {
+export declare class FormFieldEnumValue {
     id: string;
     name: string;
-};
+}

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

@@ -12,6 +12,7 @@ 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 for all BPMN elements, including Processes, Participants, Flow Nodes, etc.
+ * The base class for all BPMN elements, including processes, participants, etc.
  */
-export type BaseElement = {
+export declare abstract class BaseElement {
     id: string;
     documentation?: Array<string>;
     extensionElements?: ExtensionElements;
-};
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Describes a single Camunda specific ExecutionListener.
+ * These are wrapped in the <camunda:executionlistener></camunda:executionlistener> tag.
+ */
+export declare class CamundaExecutionListener {
+    class: any;
+    event: any;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Describes a single Camunda specific ExtensionProperty.
+ * These are wrapped in the <camunda:property></camunda:property> tag.
+ */
+export declare class CamundaExtensionProperty {
+    name: string;
+    value: string;
+}

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 type DataInputAssociation = BaseElement & {
+export declare class DataInputAssociation extends BaseElement {
     /**
      * The given name of the DataInputAssociation.
      */
@@ -16,4 +16,4 @@ export type DataInputAssociation = 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 type DataOutputAssociation = BaseElement & {
+export declare class DataOutputAssociation extends BaseElement {
     /**
      * The given name of the DataOutputAssociation.
      */
@@ -20,4 +20,4 @@ export type DataOutputAssociation = 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,18 +1,12 @@
-export type CamundaExecutionListener = {
-    class: any;
-    event: any;
-};
-export type CamundaExtensionProperty = {
-    name: string;
-    value: string;
-};
-export type SignavioMetadata = {
-    metaKey: string;
-    metaValue: string;
-};
-export type ExtensionElements = {
+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 {
     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 for all FlowNodes.
+ * Base class for all FlowNodes.
  * These include Events, Gateways and Activities.
  */
-export type FlowNode = BaseElement & {
-    readonly bpmnType: BpmnType;
+export declare abstract class FlowNode extends BaseElement {
     name: string;
+    defaultOutgoingSequenceFlowId?: string;
     /**
      * A list of all incoming sequence flow IDs.
      */
@@ -19,12 +19,12 @@ export type FlowNode = 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,4 +33,26 @@ export type FlowNode = 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;
+    /**
+     * If set, waits a timeout between loop iterations before starting the next loop in ms
+     */
+    timeoutBetweenLoopIterations?: number;
+    /**
+     * If set, throws an error, if the maximum number of iterations is exceeded
+     */
+    maxLoopIterations?: number;
+    abstract readonly bpmnType: BpmnType;
+}
+export declare enum LoopMarker {
+    Loop = 0,
+    Parallel = 1,
+    Sequential = 2
+}

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

@@ -1,9 +1,15 @@
+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,9 +93,7 @@ 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",
@@ -137,10 +135,6 @@ 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 type Collaboration = BaseElement & {
+export declare class Collaboration extends BaseElement {
     name: string;
     participants: Array<Participant>;
     messageFlows: Array<MessageFlow>;
-};
+}

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

@@ -60,25 +60,21 @@ 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"
+    timerEvent = "timerEvent",
+    errorEvent = "errorEvent"
 }

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

@@ -1,4 +1,4 @@
-import { BaseElement, ExtensionElements, FlowNode } from './Base/index';
+import { BaseElement, 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 implements BaseElement {
+export declare class Definitions extends BaseElement {
     id: string;
     displayName: string;
     /**
@@ -41,8 +41,6 @@ export declare class Definitions implements 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/BoundaryEvent.d.ts

@@ -0,0 +1,38 @@
+import { BpmnType, EventType } from '../Constants';
+import { ErrorEventDefinition, Event, TimerEventDefinition } from './EventBase';
+/**
+ * Describes a BPMN BoundaryEvent.
+ *
+ * These events are always attached to an activity and will only live
+ * as long as that activity gets executed.
+ */
+export declare class BoundaryEvent extends Event {
+    /**
+     * When using an ErrorBoundaryEvent, this will contain the BPMN error to catch.
+     */
+    errorEventDefinition?: ErrorEventDefinition;
+    /**
+     * When using a TimerBoundaryEvent, this will contain the timer used to delay the BoundaryEvent's execution.
+     */
+    timerEventDefinition?: TimerEventDefinition;
+    /**
+     * If set to true, raising this event will cause the activity to cease all operations.
+     */
+    cancelActivity: boolean;
+    /**
+     * Contains the ID of the activity to which this event is attached.
+     */
+    attachedToRef: string;
+    get bpmnType(): BpmnType;
+    get eventType(): EventType;
+    /**
+     * Optional: If set, the Flow Node Instance will only continue, if the given expression results into a value, which matches the value from triggerValueInEventPayload.
+     * Start-, Boundary- and Catch- Events only.
+     */
+    triggerValueInToken?: string;
+    /**
+     * Optional: If set, the Flow Node Instance will only continue, if the given expression results into a value, which matches the value from triggerValueInToken.
+     * Start-, Boundary- and Catch- Events only.
+     */
+    triggerValueInEventPayload?: string;
+}

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

@@ -0,0 +1,35 @@
+import { BpmnType, EventType } from '../Constants';
+import { ErrorEventDefinition, Event, TerminateEventDefinition } from './EventBase';
+/**
+ * Describes a BPMN EndEvent.
+ * These are used to finish a process.
+ *
+ * Depending on the type of EndEvent used, the process will either be finished
+ * with a success message or an error.
+ */
+export declare class EndEvent extends Event {
+    /**
+     * When using an ErrorEndEvent, this will contain the BPMN error to throw.
+     */
+    errorEventDefinition?: ErrorEventDefinition;
+    /**
+     * When using a TerminateEndEvent, this will contain the termination defintion.
+     * Note that this is actually just a placeholder and doesn't really contain anything.
+     */
+    terminateEventDefinition?: TerminateEventDefinition;
+    /**
+     * When sending messages or signals, this property can hold a
+     * definition for a payload to send with the event.
+     *
+     * Use this, if you do not want to use the current ProcessToken as event
+     * payload.
+     */
+    inputValues?: any;
+    /**
+     * Optional:
+     * When sending messages or signals, any process instance started with the message/signal will use this correlation id.
+     */
+    customCorrelationId?: any;
+    get bpmnType(): BpmnType;
+    get eventType(): EventType;
+}