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

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

@@ -1,74 +1,123 @@
-import { EventType } from '../Constants';
 import { BaseElement, FlowNode } from '../Base/index';
+import { BpmnType, EventType } from '../Constants';
 /**
- * The base class for all events.
+ * The base type for all events.
  */
-export declare abstract class Event extends FlowNode {
+export type Event = FlowNode & {
+    readonly eventType: EventType;
+};
+export type StartEvent = Event & {
+    readonly bpmnType: BpmnType.startEvent;
     /**
-     * When using a message event, this will contain the message being send/received.
+     * A list of all outgoing sequence flow IDs.
      */
-    messageEventDefinition?: MessageEventDefinition;
+    outgoing: Array<string>;
     /**
-     * When using a signal event, this will contain the signal being send/received.
+     * 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.
      */
-    signalEventDefinition?: SignalEventDefinition;
+    triggerValueInToken?: string;
     /**
-     * Gets the type of the Event (Message, Signal, etc.)
+     * 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.
      */
-    get eventType(): EventType;
-}
-/**
- * The base class of all event definitions.
- */
-export declare abstract class EventDefinition extends BaseElement {
-}
-/**
- * Contains the definition for an ErrorEvent.
- */
-export declare class ErrorEventDefinition extends EventDefinition {
-    name?: string;
-    code?: string;
-    message?: string;
-}
-/**
- * Contains the definition for a LinkEvent.
- */
-export declare class LinkEventDefinition extends EventDefinition {
-    readonly name: string;
-    constructor(linkName: string);
-}
-/**
- * Contains the definition for a MessageEvent.
- */
-export declare class MessageEventDefinition extends EventDefinition {
-    id: string;
-    name: string;
-}
-/**
- * Contains the definition for a SignalEvent.
- */
-export declare class SignalEventDefinition extends EventDefinition {
-    id: string;
-    name: string;
-}
-/**
- * Contains the definition for a TerminateEndEvent.
- */
-export declare class TerminateEventDefinition extends EventDefinition {
-}
-/**
- * Contains the definition for a TimerEvent.
- */
-export declare class TimerEventDefinition extends EventDefinition {
-    enabled?: boolean;
-    timerType: TimerType;
-    value: string;
-}
+    triggerValueInEventPayload?: string;
+};
+export type EndEvent = Event & {
+    readonly bpmnType: BpmnType.endEvent;
+    /**
+     * A list of all incoming sequence flow IDs.
+     */
+    incoming: Array<string>;
+    /**
+     * 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;
+};
+export type IntermediateCatchEvent = Event & {
+    readonly bpmnType: BpmnType.intermediateCatchEvent;
+    /**
+     * A list of all incoming sequence flow IDs.
+     */
+    incoming: Array<string>;
+    /**
+     * A list of all outgoing sequence flow IDs.
+     */
+    outgoing: Array<string>;
+    /**
+     * 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;
+};
+export type IntermediateThrowEvent = Event & {
+    readonly bpmnType: BpmnType.intermediateThrowEvent;
+    /**
+     * A list of all incoming sequence flow IDs.
+     */
+    incoming: Array<string>;
+    /**
+     * A list of all outgoing sequence flow IDs.
+     */
+    outgoing: Array<string>;
+    /**
+     * 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;
+};
+export type BoundaryEvent = Event & {
+    readonly bpmnType: BpmnType.boundaryEvent;
+    /**
+     * A list of all incoming sequence flow IDs.
+     */
+    incoming: Array<string>;
+    /**
+     * A list of all outgoing sequence flow IDs.
+     */
+    outgoing: Array<string>;
+    /**
+     * 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;
+    /**
+     * 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;
+};
 /**
- * Contains all timer types that are currently supported.
+ * The base of all event definitions.
  */
-export declare enum TimerType {
-    timeCycle = 0,
-    timeDate = 1,
-    timeDuration = 2
-}
+export type EventDefinition = BaseElement & {};

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

@@ -0,0 +1,17 @@
+import { EventType } from '../Constants';
+import { Event, EventDefinition, IntermediateCatchEvent, IntermediateThrowEvent } from './EventBase';
+/**
+ * The parameters required to configure a LinkEvent.
+ */
+export type LinkEventDefinition = EventDefinition & {
+    name: string;
+};
+/**
+ * Describes a Flow Node with a Link Event Definition.
+ */
+export type LinkEvent = Event & {
+    readonly eventType: EventType.linkEvent;
+    linkEventDefinition: LinkEventDefinition;
+};
+export type LinkIntermediateCatchEvent = IntermediateCatchEvent & LinkEvent;
+export type LinkIntermediateThrowEvent = IntermediateThrowEvent & LinkEvent;

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

@@ -0,0 +1,28 @@
+import { EventType } from '../Constants';
+import { BoundaryEvent, Event, EndEvent, EventDefinition, IntermediateCatchEvent, IntermediateThrowEvent, StartEvent } from './EventBase';
+/**
+ * Describes a global BPMN Message object.
+ */
+export type Message = {
+    id: string;
+    name: string;
+};
+/**
+ * Contains the definition for a MessageEvent.
+ */
+export type MessageEventDefinition = EventDefinition & {
+    id: string;
+    name: string;
+};
+/**
+ * Describes a Flow Node with a Message Event Definition.
+ */
+export type MessageEvent = Event & {
+    readonly eventType: EventType.messageEvent;
+    messageEventDefinition: MessageEventDefinition;
+};
+export type MessageBoundaryEvent = BoundaryEvent & MessageEvent;
+export type MessageStartEvent = StartEvent & MessageEvent;
+export type MessageEndEvent = EndEvent & MessageEvent;
+export type MessageIntermediateCatchEvent = IntermediateCatchEvent & MessageEvent;
+export type MessageIntermediateThrowEvent = IntermediateThrowEvent & MessageEvent;

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

@@ -0,0 +1,28 @@
+import { EventType } from '../Constants';
+import { BoundaryEvent, Event, EndEvent, EventDefinition, IntermediateCatchEvent, IntermediateThrowEvent, StartEvent } from './EventBase';
+/**
+ * Describes a global BPMN Signal object.
+ */
+export type Signal = {
+    id: string;
+    name: string;
+};
+/**
+ * Contains the definition for a SignalEvent.
+ */
+export type SignalEventDefinition = EventDefinition & {
+    id: string;
+    name: string;
+};
+/**
+ * Describes a Flow Node with a Signal Event Definition.
+ */
+export type SignalEvent = Event & {
+    readonly eventType: EventType.signalEvent;
+    signalEventDefinition: SignalEventDefinition;
+};
+export type SignalBoundaryEvent = BoundaryEvent & SignalEvent;
+export type SignalStartEvent = StartEvent & SignalEvent;
+export type SignalEndEvent = EndEvent & SignalEvent;
+export type SignalIntermediateCatchEvent = IntermediateCatchEvent & SignalEvent;
+export type SignalIntermediateThrowEvent = IntermediateThrowEvent & SignalEvent;

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

@@ -0,0 +1,11 @@
+import { EventType } from '../Constants';
+import { Event, EndEvent, EventDefinition } from './EventBase';
+export type TerminateEventDefinition = EventDefinition & {};
+/**
+ * Describes a Flow Node with a Terminate Event Definition.
+ */
+export type TerminateEvent = Event & {
+    readonly eventType: EventType.terminateEvent;
+    terminateEventDefinition: TerminateEventDefinition;
+};
+export type TerminateEndEvent = EndEvent & TerminateEvent;

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

@@ -0,0 +1,28 @@
+import { EventType } from '../Constants';
+import { BoundaryEvent, Event, EventDefinition, IntermediateCatchEvent, StartEvent } from './EventBase';
+/**
+ * The parameters required to configure a TimerEvent.
+ */
+export type TimerEventDefinition = EventDefinition & {
+    enabled?: boolean;
+    timerType: TimerType;
+    value: string;
+};
+/**
+ * Lists all supported timer types.
+ */
+export declare enum TimerType {
+    timeDuration = "timeDuration",
+    timeCycle = "timeCycle",
+    timeDate = "timeDate"
+}
+/**
+ * Describes a Flow Node with a Timer Event Definition.
+ */
+export type TimerEvent = Event & {
+    readonly eventType: EventType.timerEvent;
+    timerEventDefinition: TimerEventDefinition;
+};
+export type TimerBoundaryEvent = BoundaryEvent & TimerEvent;
+export type TimerStartEvent = StartEvent & TimerEvent;
+export type TimerIntermediateCatchEvent = IntermediateCatchEvent & TimerEvent;

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

@@ -1,17 +1,8 @@
-import * as definitions from './EventBase';
-export * from './BoundaryEvent';
-export * from './EndEvent';
+export * from './ConditionalEvents';
+export * from './ErrorEvents';
 export * from './EventBase';
-export * from './IntermediateCatchEvent';
-export * from './IntermediateThrowEvent';
-export * from './StartEvent';
-export declare namespace Definitions {
-    export import ErrorEventDefinition = definitions.ErrorEventDefinition;
-    export import EventDefinition = definitions.EventDefinition;
-    export import LinkEventDefinition = definitions.LinkEventDefinition;
-    export import MessageEventDefinition = definitions.MessageEventDefinition;
-    export import SignalEventDefinition = definitions.SignalEventDefinition;
-    export import TerminateEventDefinition = definitions.TerminateEventDefinition;
-    export import TimerEventDefinition = definitions.TimerEventDefinition;
-    export import TimerType = definitions.TimerType;
-}
+export * from './LinkEvents';
+export * from './MessageEvents';
+export * from './SignalEvents';
+export * from './TerminateEvents';
+export * from './TimerEvents';

package/dist/ProcessModel/Model/Gateways/Gateway.d.ts

@@ -1,17 +1,5 @@
 import { FlowNode } from '../Base/index';
-/**
- * The base class for gateways.
- */
-export declare abstract class Gateway extends FlowNode {
-    /**
-     * Determines the direction of the gateway.
-     *
-     * If no incoming and/or no outgoing SequenceFlows are associated with the
-     * gateway, the direction will be 'unspecified', effectively rendering this
-     * gateway non-executable.
-     */
-    get gatewayDirection(): GatewayDirection;
-}
+import { BpmnType } from '../Constants';
 /**
  * Contains all possible Gateway directions.
  *
@@ -23,3 +11,64 @@ export declare enum GatewayDirection {
     Diverging = "diverging",
     Mixed = "mixed"
 }
+/**
+ * The base type for gateways.
+ */
+export type Gateway = FlowNode & {
+    /**
+     * Determines the direction of the gateway.
+     *
+     * If no incoming and/or no outgoing SequenceFlows are associated with the
+     * gateway, the direction will be 'unspecified', effectively rendering this
+     * gateway non-executable.
+     */
+    gatewayDirection: GatewayDirection;
+};
+/**
+ * Describes a ComplexGateway.
+ *
+ * Currently not supported.
+ */
+export type ComplexGateway = Gateway & {
+    readonly bpmnType: BpmnType.complexGateway;
+};
+/**
+ * Describes an EventBasedGateway.
+ *
+ * These gateways are used to direct the Process across a specific path, based on annotated catch events.
+ */
+export type EventBasedGateway = Gateway & {
+    readonly bpmnType: BpmnType.eventBasedGateway;
+};
+/**
+ * Describes an ExclusiveGateway.
+ *
+ * These gateways are used to direct the process to a specific conditional branch.
+ */
+export type ExclusiveGateway = Gateway & {
+    readonly bpmnType: BpmnType.exclusiveGateway;
+    /**
+     * Optional: The ID of the Sequence Flow to take, if no other Sequence Flows have a fulfilled condition.
+     */
+    defaultOutgoingSequenceFlowId?: string;
+};
+/**
+ * Describes an InclusiveGateway.
+ *
+ * They are used to run multiple conditional branches in parallel.
+ */
+export type InclusiveGateway = Gateway & {
+    readonly bpmnType: BpmnType.inclusiveGateway;
+    /**
+     * Optional: The ID of the Sequence Flow to take, if no other Sequence Flows have a fulfilled condition.
+     */
+    defaultOutgoingSequenceFlowId?: string;
+};
+/**
+ * Describes a ParallelGateway.
+ *
+ * These gateways are used to run multiple branches in parallel.
+ */
+export type ParallelGateway = Gateway & {
+    readonly bpmnType: BpmnType.parallelGateway;
+};

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

@@ -1,6 +1 @@
-export * from './ComplexGateway';
-export * from './EventBasedGateway';
-export * from './ExclusiveGateway';
 export * from './Gateway';
-export * from './InclusiveGateway';
-export * from './ParallelGateway';

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

@@ -2,7 +2,7 @@ import { BaseElement } from './Base/index';
 /**
  * Describes a BPMN Participant of a Collaboration.
  */
-export declare class Participant extends BaseElement {
+export type Participant = BaseElement & {
     name: string;
     processReference: string;
-}
+};

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

@@ -1,4 +1,4 @@
-import { BaseElement, FlowNode } from './Base/index';
+import { BaseElement, ExtensionElements, FlowNode } from './Base/index';
 import { EndEvent, StartEvent } from './Events/index';
 import { Association, DataObject, DataObjectReference, DataStoreReference, LaneSet, SequenceFlow } from './ProcessElements/index';
 import { BpmnType } from './Constants';
@@ -6,7 +6,11 @@ import { BpmnType } from './Constants';
  * Describes a BPMN Process.
  * Any and all information about FlowNodes, SequenceFlows and Lanes is stored here.
  */
-export declare class Process extends BaseElement {
+export declare class Process implements BaseElement {
+    /**
+     * The ID of the process.
+     */
+    id: string;
     /**
      * The name of the process.
      */
@@ -48,6 +52,8 @@ export declare class Process extends BaseElement {
      * Each DataObject is bound to a specific process and cannot be shared across multiple processs.
      */
     dataObjects: Array<DataObject>;
+    documentation?: Array<string>;
+    extensionElements?: ExtensionElements;
     /**
      * Returns all StartEvents contained in this process.
      */

package/dist/ProcessModel/Model/ProcessElements/Association.d.ts

@@ -1,11 +1,10 @@
 import { BaseElement } from '../Base/index';
 /**
  * Contains a BPMN Association.
- * These associations are used to link FlowNode elements with annotations,
- * such as TextAnnotations.
+ * These associations are used to link FlowNode elements with annotations, such as TextAnnotations.
  */
-export declare class Association extends BaseElement {
+export type Association = BaseElement & {
     name?: string;
     sourceRef: string;
     targetRef: string;
-}
+};

package/dist/ProcessModel/Model/ProcessElements/DataObject.d.ts

@@ -1,17 +1,16 @@
 import { BaseElement } from '../Base/index';
 /**
  * Contains a BPMN DataObject.
- * DataObjects are used to store global process informations.
+ * DataObjects are used to store data within the Scope of a ProcessInstance, so that all Elements of the process can access it.
  */
-export declare class DataObject extends BaseElement {
-}
+export type DataObject = BaseElement & {};
 /**
  * Contains a reference to a DataObject.
  */
-export declare class DataObjectReference extends BaseElement {
+export type DataObjectReference = BaseElement & {
     name?: string;
     /**
      * The name of the DataObject the reference points to.
      */
     dataObjectRef: string;
-}
+};

package/dist/ProcessModel/Model/ProcessElements/DataStoreReference.d.ts

@@ -2,8 +2,8 @@ import { BaseElement } from '../Base/index';
 /**
  * Contains a reference to a DataStore.
  *
- * NOT SUPPORTED YET.
+ * Has only symbolic value and doesn't actually do anything.
  */
-export declare class DataStoreReference extends BaseElement {
+export type DataStoreReference = BaseElement & {
     name?: string;
-}
+};

package/dist/ProcessModel/Model/ProcessElements/Lane.d.ts

@@ -6,8 +6,8 @@ import { LaneSet } from './LaneSet';
  * The FlowNodes themselves are stored directly in the ProcessModel.
  * This reflects the original XML structure as defined by the BPMN specs.
  */
-export declare class Lane extends BaseElement {
+export type Lane = BaseElement & {
     name: string;
     flowNodeReferences: Array<string>;
     childLaneSet?: LaneSet;
-}
+};

package/dist/ProcessModel/Model/ProcessElements/LaneSet.d.ts

@@ -3,6 +3,6 @@ import { Lane } from './Lane';
 /**
  * Describes a BPMN LaneSet; in essence a collection of lanes.
  */
-export declare class LaneSet extends BaseElement {
+export type LaneSet = BaseElement & {
     lanes: Array<Lane>;
-}
+};

package/dist/ProcessModel/Model/{GlobalElements → ProcessElements}/MessageFlow.d.ts

@@ -3,10 +3,10 @@ import { BaseElement } from '../Base/index';
  * Contains a BPMN MessageFlow.
  * These are used to showcase the communication between FlowNodes from different processes.
  *
- * For example: "SendTask 1" from Process A sends a message to "ReceiveTask 1" on Process B.
+ * They have symbolic value only and don't actually do anything.
  */
-export declare class MessageFlow extends BaseElement {
+export type MessageFlow = BaseElement & {
     name?: string;
     sourceRef: string;
     targetRef: string;
-}
+};

package/dist/ProcessModel/Model/ProcessElements/SequenceFlow.d.ts

@@ -1,17 +1,15 @@
 import { BaseElement } from '../Base/index';
 /**
- * Describes a BPMN SequenceFlow element, which is used to connect
- * two FlowNodes together.
+ * Describes a BPMN SequenceFlow element, which is used to connect two FlowNodes together.
  */
-export declare class SequenceFlow extends BaseElement {
+export type SequenceFlow = BaseElement & {
     name: string;
     sourceRef: string;
     targetRef: string;
     conditionExpression?: IConditionExpression;
-}
+};
 /**
- * Describes a conditional expression that can be placed on
- * a SequenceFlow.
+ * Describes a conditional expression that can be placed on a SequenceFlow.
  */
 export interface IConditionExpression {
     type: string;

package/dist/ProcessModel/Model/ProcessElements/TextAnnotation.d.ts

@@ -2,6 +2,6 @@ import { BaseElement } from '../Base/index';
 /**
  * Describes a BPMN TextAnnotation element.
  */
-export declare class TextAnnotation extends BaseElement {
+export type TextAnnotation = BaseElement & {
     text: string;
-}
+};

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

@@ -3,5 +3,6 @@ export * from './DataObject';
 export * from './DataStoreReference';
 export * from './Lane';
 export * from './LaneSet';
+export * from './MessageFlow';
 export * from './SequenceFlow';
 export * from './TextAnnotation';

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

@@ -1,7 +1,7 @@
 /**
  * Encapsulates the tags contained within the xmlns-header tags of a BPMN file.
  */
-export declare class Xmlns {
+export type Xmlns = {
     bpmn: string;
     bpmndi: string;
     di: string;
@@ -11,4 +11,4 @@ export declare class Xmlns {
     signavio: string;
     camunda: string;
     xsi: string;
-}
+};

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

@@ -3,7 +3,6 @@ import * as base from './Base/index';
 import * as bpmnTags from './BpmnComponentTags';
 import * as events from './Events/index';
 import * as gateways from './Gateways/index';
-import * as globalElements from './GlobalElements/index';
 import * as processElements from './ProcessElements/index';
 import * as collaboration from './Collaboration';
 import * as definition from './Definitions';
@@ -17,7 +16,6 @@ export declare namespace Model {
     export import Definitions = definition.Definitions;
     export import Events = events;
     export import Gateways = gateways;
-    export import GlobalElements = globalElements;
     export import Participant = participant.Participant;
     export import Process = process.Process;
     export import ProcessElements = processElements;
@@ -25,6 +23,7 @@ export declare namespace Model {
 }
 export declare namespace BpmnTags {
     export import CamundaProperty = bpmnTags.CamundaProperty;
+    export import SignavioProperty = bpmnTags.SignavioProperty;
     export import CommonElement = bpmnTags.CommonElement;
     export import GatewayElement = bpmnTags.GatewayElement;
     export import EventElement = bpmnTags.EventElement;
@@ -36,4 +35,3 @@ export declare namespace BpmnTags {
     export import LoopMarkers = bpmnTags.LoopMarkers;
 }
 export * from './Constants';
-export * from './ProcessList';