@5minds/processcube_engine_sdk 3.3.0

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

@@ -0,0 +1,134 @@
+/**
+ * Contains all BPMN tags which are commonly used with all processes.
+ * These tags are usually found at the root level of the process or the definition.
+ */
+export declare enum CommonElement {
+    Collaboration = "bpmn:collaboration",
+    Definitions = "bpmn:definitions",
+    Diagram = "bpmndi:BPMNDiagram",
+    Participant = "bpmn:participant",
+    Process = "bpmn:process",
+    Error = "bpmn:error",
+    Signal = "bpmn:signal",
+    Message = "bpmn:message",
+    DataStoreReference = "bpmn:dataStoreReference",
+    DataStore = "bpmn:dataStore",
+    DataObjectReference = "bpmn:dataObjectReference",
+    DataObject = "bpmn:dataObject",
+    Association = "bpmn:association",
+    DataInputAssociation = "bpmn:dataInputAssociation",
+    DataOutputAssociation = "bpmn:dataOutputAssociation",
+    MessageFlow = "bpmn:messageFlow",
+    SequenceFlow = "bpmn:sequenceFlow",
+    TextAnnotation = "bpmn:textAnnotation",
+    BpmnSourceRef = "bpmn:sourceRef",
+    BpmnTargetRef = "bpmn:targetRef"
+}
+/**
+ * Contains all XML tags contained within the "xmlns" header tag.
+ */
+export declare enum XmlnsProperty {
+    bpmn = "xmlns:bpmn",
+    bpmndi = "xmlns:bpmndi",
+    di = "xmlns:di",
+    dc = "xmlns:dc",
+    camunda = "xmlns:camunda",
+    xsi = "xmlns:xsi"
+}
+/**
+ * Contains all tags associated with lanes and lane sets.
+ */
+export declare enum Lane {
+    Lane = "bpmn:lane",
+    LaneSet = "bpmn:laneSet"
+}
+/**
+ * Contains all tags that a lane can have.
+ */
+export declare enum LaneProperty {
+    ChildLaneSet = "bpmn:childLaneSet",
+    FlowNodeRef = "bpmn:flowNodeRef"
+}
+/**
+ * Contains the tags for all known gateway types.
+ */
+export declare enum GatewayElement {
+    ComplexGateway = "bpmn:complexGateway",
+    EventBasedGateway = "bpmn:eventBasedGateway",
+    ExclusiveGateway = "bpmn:exclusiveGateway",
+    InclusiveGateway = "bpmn:inclusiveGateway",
+    ParallelGateway = "bpmn:parallelGateway"
+}
+/**
+ * Contains the tags for all known event types.
+ */
+export declare enum EventElement {
+    StartEvent = "bpmn:startEvent",
+    EndEvent = "bpmn:endEvent",
+    Boundary = "bpmn:boundaryEvent",
+    IntermediateCatchEvent = "bpmn:intermediateCatchEvent",
+    IntermediateThrowEvent = "bpmn:intermediateThrowEvent"
+}
+/**
+ * Contains the tags for all known task types.
+ */
+export declare enum TaskElement {
+    EmptyActivity = "bpmn:task",
+    CallActivity = "bpmn:callActivity",
+    SubProcess = "bpmn:subProcess",
+    BusinessRuleTask = "bpmn:businessRuleTask",
+    ManualTask = "bpmn:manualTask",
+    ScriptTask = "bpmn:scriptTask",
+    ServiceTask = "bpmn:serviceTask",
+    UserTask = "bpmn:userTask",
+    SendTask = "bpmn:sendTask",
+    ReceiveTask = "bpmn:receiveTask",
+    MethodInvocation = "bpmn:methodInvocation",
+    WebServiceInvocation = "bpmn:webServiceInvocation"
+}
+/**
+ * Contains all BPMN tags that a BPMN element can have.
+ */
+export declare enum FlowElementProperty {
+    ErrorEventDefinition = "bpmn:errorEventDefinition",
+    LinkEventDefinition = "bpmn:linkEventDefinition",
+    MessageEventDefinition = "bpmn:messageEventDefinition",
+    SignalEventDefinition = "bpmn:signalEventDefinition",
+    TerminateEventDefinition = "bpmn:terminateEventDefinition",
+    TimerEventDefinition = "bpmn:timerEventDefinition",
+    BpmnScript = "bpmn:script",
+    ConditionExpression = "bpmn:conditionExpression",
+    Documentation = "bpmn:documentation",
+    ExtensionElements = "bpmn:extensionElements",
+    DataInputAssociation = "bpmn:dataInputAssociation",
+    DataOutputAssociation = "bpmn:dataOutputAssociation",
+    SequenceFlowIncoming = "bpmn:incoming",
+    SequenceFlowOutgoing = "bpmn:outgoing",
+    XsiType = "xsi:type"
+}
+/**
+ * Contains all Camunda tags that a BPMN element can have.
+ */
+export declare enum CamundaProperty {
+    CalledElementBinding = "camunda:calledElementBinding",
+    CalledElementVersion = "camunda:calledElementVersion",
+    CalledElementTenantId = "camunda:calledElementTenantId",
+    Assignee = "camunda:assignee",
+    CandidateUsers = "camunda:candidateUsers",
+    CandidateGroups = "camunda:candidateGroups",
+    DueDate = "camunda:dueDate",
+    ExecutionListener = "camunda:executionListener",
+    Expression = "camunda:expression",
+    FormData = "camunda:formData",
+    FormField = "camunda:formField",
+    FollowupDate = "camunda:followUpDate",
+    Properties = "camunda:properties",
+    Property = "camunda:property",
+    ResultVariable = "camunda:resultVariable",
+    Topic = "camunda:topic",
+    Type = "camunda:type",
+    Value = "camunda:value",
+    VariableMappingClass = "camunda:variableMappingClass",
+    VariableMappingDelegateExpression = "camunda:variableMappingDelegateExpression",
+    ErrorMessageVariable = "camunda:errorMessageVariable"
+}

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

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

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

@@ -0,0 +1,80 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     BpmnType:
+ *       description: The type of a BPMN element.
+ *       type: string
+ *       enum:
+ *         - bpmn:Task
+ *         - bpmn:BusinessRuleTask
+ *         - bpmn:UserTask
+ *         - bpmn:ExclusiveGateway
+ *         - bpmn:ParallelGateway
+ *         - bpmn:ServiceTask
+ *         - bpmn:StartEvent
+ *         - bpmn:EndEvent
+ *         - bpmn:IntermediateCatchEvent
+ *         - bpmn:IntermediateThrowEvent
+ *         - bpmn:ScriptTask
+ *         - bpmn:BoundaryEvent
+ *         - bpmn:CallActivity
+ *         - bpmn:SubProcess
+ *         - bpmn:ManualTask
+ *         - bpmn:ComplexGateway
+ *         - bpmn:InclusiveGateway
+ *         - bpmn:EventBasedGateway
+ *         - bpmn:SendTask
+ *         - bpmn:ReceiveTask
+ */
+/**
+ * Contains a list of all known BPMN types and maps them to their corresponding XML tag.
+ */
+export declare enum BpmnType {
+    emptyActivity = "bpmn:Task",
+    businessRuleTask = "bpmn:BusinessRuleTask",
+    userTask = "bpmn:UserTask",
+    exclusiveGateway = "bpmn:ExclusiveGateway",
+    parallelGateway = "bpmn:ParallelGateway",
+    serviceTask = "bpmn:ServiceTask",
+    startEvent = "bpmn:StartEvent",
+    endEvent = "bpmn:EndEvent",
+    intermediateCatchEvent = "bpmn:IntermediateCatchEvent",
+    intermediateThrowEvent = "bpmn:IntermediateThrowEvent",
+    scriptTask = "bpmn:ScriptTask",
+    boundaryEvent = "bpmn:BoundaryEvent",
+    callActivity = "bpmn:CallActivity",
+    subProcess = "bpmn:SubProcess",
+    manualTask = "bpmn:ManualTask",
+    complexGateway = "bpmn:ComplexGateway",
+    inclusiveGateway = "bpmn:InclusiveGateway",
+    eventBasedGateway = "bpmn:EventBasedGateway",
+    sendTask = "bpmn:SendTask",
+    receiveTask = "bpmn:ReceiveTask"
+}
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     EventType:
+ *       description: The type of an event.
+ *       type: string
+ *       enum:
+ *         - linkEvent
+ *         - messageEvent
+ *         - signalEvent
+ *         - terminateEvent
+ *         - timerEvent
+ *         - errorEvent
+ */
+/**
+ * Contains a list of all supported event types.
+ */
+export declare enum EventType {
+    linkEvent = "linkEvent",
+    messageEvent = "messageEvent",
+    signalEvent = "signalEvent",
+    terminateEvent = "terminateEvent",
+    timerEvent = "timerEvent",
+    errorEvent = "errorEvent"
+}

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

@@ -0,0 +1,55 @@
+import { BaseElement, FlowNode } from './Base/index';
+import { Collaboration } from './Collaboration';
+import { EndEvent, StartEvent } from './Events/index';
+import { Process } from './Process';
+import { Xmlns } from './XMLNS';
+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 {
+    id: string;
+    displayName: string;
+    /**
+     * The date at which the diagram was deployed to the engine.
+     */
+    deployedAt: Date;
+    /**
+     * The id of the user that deployed the diagram to the engine.
+     */
+    deployedByUserId: string;
+    /**
+     * The hash under which the raw xml has been stored.
+     */
+    hash: string;
+    /**
+     * The process' raw xml.
+     */
+    raw: string;
+    xmlns: Xmlns;
+    targetNamespace: string;
+    exporter: string;
+    exporterVersion: string;
+    /**
+     * Contains information about the Collaboration associated with this
+     * ProcessDefiniton, such as the participants.
+     */
+    collaboration: Collaboration;
+    /**
+     * Contains a list of all processes contained within this definition.
+     */
+    processes: Array<Process>;
+    /**
+     * Gets a list of all StartEvents contained in this ProcessDefinition.
+     */
+    getAllStartEvents(): Array<StartEvent>;
+    /**
+     * Gets a list of all EndEvents contained in this ProcessDefinition.
+     */
+    getAllEndEvents(): Array<EndEvent>;
+    /**
+     * Returns all FlowNodes that match the given type.
+     */
+    getFlowNodesByType(bpmnType: BpmnType): Array<FlowNode>;
+}

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;
+}

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

@@ -0,0 +1,74 @@
+import { EventType } from '../Constants';
+import { BaseElement, FlowNode } from '../Base/index';
+/**
+ * The base class for all events.
+ */
+export declare abstract class Event extends FlowNode {
+    /**
+     * When using a message event, this will contain the message being send/received.
+     */
+    messageEventDefinition?: MessageEventDefinition;
+    /**
+     * When using a signal event, this will contain the signal being send/received.
+     */
+    signalEventDefinition?: SignalEventDefinition;
+    /**
+     * Gets the type of the Event (Message, Signal, etc.)
+     */
+    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;
+}
+/**
+ * Contains all timer types that are currently supported.
+ */
+export declare enum TimerType {
+    timeCycle = 0,
+    timeDate = 1,
+    timeDuration = 2
+}

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

@@ -0,0 +1,34 @@
+import { BpmnType, EventType } from '../Constants';
+import { Event, LinkEventDefinition, TimerEventDefinition } from './EventBase';
+/**
+ * Describes a BPMN IntermediateThrowEvent.
+ *
+ * These are used to wait for events during ProcessModel execution.
+ *
+ * The only exception is the IntermediateTimerCatchEvent, which is used to halt
+ * the execution for a given amount of time.
+ */
+export declare class IntermediateCatchEvent extends Event {
+    /**
+     * When using an IntermediateLinkCatchEvent, this will contain the link by
+     * which to access this event.
+     */
+    linkEventDefinition?: LinkEventDefinition;
+    /**
+     * When using an IntermediateTimerCatchEvent, this will contain the definiton
+     * of the timer that is used to pause the execution.
+     */
+    timerEventDefinition?: TimerEventDefinition;
+    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/IntermediateThrowEvent.d.ts

@@ -0,0 +1,29 @@
+import { BpmnType, EventType } from '../Constants';
+import { Event, LinkEventDefinition } from './EventBase';
+/**
+ * Describes a BPMN IntermediateThrowEvent.
+ *
+ * These are used to raise events during ProcessModel execution.
+ */
+export declare class IntermediateThrowEvent extends Event {
+    /**
+     * When using an IntermediateLinkThrowEvent, this will contain the link that
+     * gets called.
+     */
+    linkEventDefinition?: LinkEventDefinition;
+    /**
+     * 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;
+}

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

@@ -0,0 +1,23 @@
+import { BpmnType, EventType } from '../Constants';
+import { Event, TimerEventDefinition } from './EventBase';
+/**
+ * Describes a BPMN StartEvent.
+ */
+export declare class StartEvent extends Event {
+    /**
+     * When using a TimerStartEvent, this will contain the timer used to delay the StartEvent.
+     */
+    timerEventDefinition?: TimerEventDefinition;
+    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/index.d.ts

@@ -0,0 +1,17 @@
+import * as definitions from './EventBase';
+export * from './BoundaryEvent';
+export * from './EndEvent';
+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;
+}

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

@@ -0,0 +1,10 @@
+import { BpmnType } from '../Constants';
+import { Gateway } from './Gateway';
+/**
+ * Describes a ComplexGateway.
+ *
+ * Currently not supported.
+ */
+export declare class ComplexGateway extends Gateway {
+    get bpmnType(): BpmnType;
+}

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

@@ -0,0 +1,10 @@
+import { BpmnType } from '../Constants';
+import { Gateway } from './Gateway';
+/**
+ * Describes an EventBasedGateway.
+ *
+ * Currently not supported.
+ */
+export declare class EventBasedGateway extends Gateway {
+    get bpmnType(): BpmnType;
+}

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

@@ -0,0 +1,10 @@
+import { BpmnType } from '../Constants';
+import { Gateway } from './Gateway';
+/**
+ * Describes an ExclusiveGateway.
+ *
+ * These gateways are used for conditional branch execution.
+ */
+export declare class ExclusiveGateway extends Gateway {
+    get bpmnType(): BpmnType;
+}

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

@@ -0,0 +1,25 @@
+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;
+}
+/**
+ * Contains all possible Gateway directions.
+ *
+ * Mixed Gateways are currently not supported.
+ * */
+export declare enum GatewayDirection {
+    Unspecified = "unspecified",
+    Converging = "converging",
+    Diverging = "diverging",
+    Mixed = "mixed"
+}

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

@@ -0,0 +1,10 @@
+import { BpmnType } from '../Constants';
+import { Gateway } from './Gateway';
+/**
+ * Describes an InclusiveGateway.
+ *
+ * Currently not supported.
+ */
+export declare class InclusiveGateway extends Gateway {
+    get bpmnType(): BpmnType;
+}

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

@@ -0,0 +1,10 @@
+import { BpmnType } from '../Constants';
+import { Gateway } from './Gateway';
+/**
+ * Describes a ParallelGateway.
+ *
+ * These gateways are used to run multiple branches in parallel.
+ */
+export declare class ParallelGateway extends Gateway {
+    get bpmnType(): BpmnType;
+}

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

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

package/dist/ProcessModel/Model/GlobalElements/Error.d.ts

@@ -0,0 +1,10 @@
+import { BaseElement } from '../Base/index';
+/**
+ * Describes a global BPMN error element.
+ * Can be thrown by an ErrorEndEvent and caught by an ErrorBoundaryEvent.
+ */
+export declare class Error extends BaseElement {
+    name?: string;
+    code?: string;
+    message?: string;
+}

package/dist/ProcessModel/Model/GlobalElements/Message.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Describes a BPMN Message, which can be sent/received by MessageEvents.
+ */
+export declare class Message {
+    id: string;
+    name: string;
+}

package/dist/ProcessModel/Model/GlobalElements/MessageFlow.d.ts

@@ -0,0 +1,12 @@
+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.
+ */
+export declare class MessageFlow extends BaseElement {
+    name?: string;
+    sourceRef: string;
+    targetRef: string;
+}

package/dist/ProcessModel/Model/GlobalElements/Signal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Describes a BPMN Signal element.
+ */
+export declare class Signal {
+    id: string;
+    name: string;
+}