@5minds/processcube_engine_sdk 3.3.0

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

@@ -0,0 +1,4 @@
+export * from './Error';
+export * from './MessageFlow';
+export * from './Message';
+export * from './Signal';

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

@@ -0,0 +1,8 @@
+import { BaseElement } from './Base/index';
+/**
+ * Describes a BPMN Participant of a Collaboration.
+ */
+export declare class Participant extends BaseElement {
+    name: string;
+    processReference: string;
+}

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

@@ -0,0 +1,63 @@
+import { BaseElement, FlowNode } from './Base/index';
+import { EndEvent, StartEvent } from './Events/index';
+import { Association, DataObject, DataObjectReference, DataStoreReference, LaneSet, SequenceFlow } from './ProcessElements/index';
+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 {
+    /**
+     * The name of the process.
+     */
+    name?: string;
+    /**
+     * The annotated version of the process.
+     */
+    version?: string;
+    /**
+     * If false, this process is currently not executable.
+     */
+    isExecutable: boolean;
+    /**
+     * The lanes contained in this process.
+     */
+    laneSet?: LaneSet;
+    /**
+     * A list of all FlowNodes contained in this process.
+     */
+    flowNodes: Array<FlowNode>;
+    /**
+     * SequenceFlows link two FlowNodes together.
+     */
+    sequenceFlows: Array<SequenceFlow>;
+    /**
+     * Associations link a FlowNode to a TextAnnotation.
+     */
+    associations: Array<Association>;
+    /**
+     * DataStoreReferences contain references to a permanent data store (Database, FileSystem, etc) that lies outside of the ProcessEngine.
+     */
+    dataStoreReferences: Array<DataStoreReference>;
+    /**
+     * DataObjectReferences contain references to a specific DataObject.
+     */
+    dataObjectReferences: Array<DataObjectReference>;
+    /**
+     * DataObjects can be used to store data during ProcessInstance execution.
+     * Each DataObject is bound to a specific process and cannot be shared across multiple processs.
+     */
+    dataObjects: Array<DataObject>;
+    /**
+     * Returns all StartEvents contained in this process.
+     */
+    getStartEvents(): Array<StartEvent>;
+    /**
+     * Returns all EndEvents contained in this process.
+     */
+    getEndEvents(): Array<EndEvent>;
+    /**
+     * Returns all FlowNodes that match the given type.
+     */
+    getFlowNodesByType(bpmnType: BpmnType): Array<FlowNode>;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { BaseElement } from '../Base/index';
+/**
+ * Contains a BPMN DataObject.
+ * DataObjects are used to store global process informations.
+ */
+export declare class DataObject extends BaseElement {
+}
+/**
+ * Contains a reference to a DataObject.
+ */
+export declare class DataObjectReference extends BaseElement {
+    name?: string;
+    /**
+     * The name of the DataObject the reference points to.
+     */
+    dataObjectRef: string;
+}

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

@@ -0,0 +1,9 @@
+import { BaseElement } from '../Base/index';
+/**
+ * Contains a reference to a DataStore.
+ *
+ * NOT SUPPORTED YET.
+ */
+export declare class DataStoreReference extends BaseElement {
+    name?: string;
+}

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

@@ -0,0 +1,13 @@
+import { BaseElement } from '../Base/index';
+import { LaneSet } from './LaneSet';
+/**
+ * Describes a BPMN Lane.
+ * Note that the lane itself contains only the references to its FlowNodes.
+ * 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 {
+    name: string;
+    flowNodeReferences: Array<string>;
+    childLaneSet?: LaneSet;
+}

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

@@ -0,0 +1,8 @@
+import { BaseElement } from '../Base/index';
+import { Lane } from './Lane';
+/**
+ * Describes a BPMN LaneSet; in essence a collection of lanes.
+ */
+export declare class LaneSet extends BaseElement {
+    lanes: Array<Lane>;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { BaseElement } from '../Base/index';
+/**
+ * Describes a BPMN TextAnnotation element.
+ */
+export declare class TextAnnotation extends BaseElement {
+    text: string;
+}

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

@@ -0,0 +1,7 @@
+export * from './Association';
+export * from './DataObject';
+export * from './DataStoreReference';
+export * from './Lane';
+export * from './LaneSet';
+export * from './SequenceFlow';
+export * from './TextAnnotation';

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

@@ -0,0 +1,5 @@
+import { Process } from './Process';
+export declare class ProcessList {
+    processModels: Array<Process>;
+    totalCount: number;
+}

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

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

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

@@ -0,0 +1,38 @@
+import * as activities from './Activities/index';
+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';
+import * as participant from './Participant';
+import * as process from './Process';
+import * as xmlns from './XMLNS';
+export declare namespace Model {
+    export import Activities = activities;
+    export import Base = base;
+    export import Collaboration = collaboration.Collaboration;
+    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;
+    export import Xmlns = xmlns.Xmlns;
+}
+export declare namespace BpmnTags {
+    export import CamundaProperty = bpmnTags.CamundaProperty;
+    export import CommonElement = bpmnTags.CommonElement;
+    export import GatewayElement = bpmnTags.GatewayElement;
+    export import EventElement = bpmnTags.EventElement;
+    export import TaskElement = bpmnTags.TaskElement;
+    export import FlowElementProperty = bpmnTags.FlowElementProperty;
+    export import Lane = bpmnTags.Lane;
+    export import LaneProperty = bpmnTags.LaneProperty;
+    export import XmlnsProperty = bpmnTags.XmlnsProperty;
+}
+export * from './Constants';
+export * from './ProcessList';

package/dist/ProcessModel/ProcessModelFacade/ProcessModelFacade.d.ts

@@ -0,0 +1,43 @@
+import { BpmnType, Model } from '../Model/index';
+import { SubProcessModelFacade } from './index';
+export declare class ProcessModelFacade {
+    protected processModel: Model.Process;
+    constructor(processModel: Model.Process);
+    getIsExecutable(): boolean;
+    getSubProcessModelFacade(subProcessNode: Model.Activities.SubProcess): SubProcessModelFacade;
+    getFlowNodesByType<TFlowNode extends Model.Base.FlowNode>(flowNodeType: BpmnType): Array<TFlowNode>;
+    getStartEvents(): Array<Model.Events.StartEvent>;
+    getSingleStartEvent(): Model.Events.StartEvent;
+    getStartEventById(startEventId: string): Model.Events.StartEvent;
+    getEndEvents(): Array<Model.Events.EndEvent>;
+    getUserTasks(): Array<Model.Activities.UserTask>;
+    getFlowNodeById(flowNodeId: string): Model.Base.FlowNode;
+    getProcessModelHasLanes(): boolean;
+    getLaneForFlowNode(flowNodeId: string): Model.ProcessElements.Lane;
+    getIncomingSequenceFlowsFor(flowNodeId: string): Array<Model.ProcessElements.SequenceFlow>;
+    getOutgoingSequenceFlowsFor(flowNodeId: string): Array<Model.ProcessElements.SequenceFlow>;
+    getSequenceFlowBetween(sourceNode: Model.Base.FlowNode, targetNode: Model.Base.FlowNode): Model.ProcessElements.SequenceFlow;
+    getBoundaryEventsFor(flowNode: Model.Base.FlowNode): Array<Model.Events.BoundaryEvent>;
+    getPreviousFlowNodesFor(flowNode: Model.Base.FlowNode): Array<Model.Base.FlowNode>;
+    getNextFlowNodesFor(flowNode: Model.Base.FlowNode): Array<Model.Base.FlowNode>;
+    getLinkCatchEventsByLinkName(linkName: string): Array<Model.Events.IntermediateCatchEvent>;
+    findJoinGatewayAfterSplitGateway(splitGateway: Model.Gateways.Gateway): Model.Gateways.Gateway;
+    getDataObjects(): Array<Model.ProcessElements.DataObject>;
+    getInputDataObjectReferences(): Array<Model.ProcessElements.DataObjectReference>;
+    getOutputDataObjectReferencesForFlowNode(flowNodeId: string): Array<Model.ProcessElements.DataObjectReference>;
+    protected filterFlowNodesByType<TFlowNode extends Model.Base.FlowNode>(type: BpmnType): Array<TFlowNode>;
+    /**
+     * Iterates over the lanes of the given laneSet and determines if one of
+     * the lanes contains a FlowNode with the given ID.
+     *
+     * If the lane has a childLaneSet, the FlowNodeID will be searched within
+     * that child lane set.
+     *
+     * @param   flowNodeId The FlowNodeId to find.
+     * @param   laneSet    The LaneSet in which to search for the FlowNodeId.
+     * @returns            Either the lane containing the FlowNodeId,
+     *                     or undefined, if not matching lane was found.
+     */
+    protected findLaneForFlowNodeIdFromLaneSet(flowNodeId: string, laneSet: Model.ProcessElements.LaneSet): Model.ProcessElements.Lane;
+    private getParallelJoinGatewaysForCurrentBranch;
+}

package/dist/ProcessModel/ProcessModelFacade/SubProcessModelFacade.d.ts

@@ -0,0 +1,26 @@
+import { BpmnType, Model } from '../Model/index';
+import { ProcessModelFacade } from './index';
+export declare class SubProcessModelFacade extends ProcessModelFacade {
+    private subProcessActivity;
+    constructor(processModel: Model.Process, subProcessActivity: Model.Activities.SubProcess);
+    getStartEvents(): Array<Model.Events.StartEvent>;
+    getSingleStartEvent(): Model.Events.StartEvent;
+    getStartEventById(startEventId: string): Model.Events.StartEvent;
+    getEndEvents(): Array<Model.Events.EndEvent>;
+    getUserTasks(): Array<Model.Activities.UserTask>;
+    getFlowNodeById(flowNodeId: string): Model.Base.FlowNode;
+    getProcessModelHasLanes(): boolean;
+    getIncomingSequenceFlowsFor(flowNodeId: string): Array<Model.ProcessElements.SequenceFlow>;
+    getOutgoingSequenceFlowsFor(flowNodeId: string): Array<Model.ProcessElements.SequenceFlow>;
+    getSequenceFlowBetween(sourceNode: Model.Base.FlowNode, targetNode: Model.Base.FlowNode): Model.ProcessElements.SequenceFlow;
+    getBoundaryEventsFor(flowNode: Model.Base.FlowNode): Array<Model.Events.BoundaryEvent>;
+    getPreviousFlowNodesFor(flowNode: Model.Base.FlowNode): Array<Model.Base.FlowNode>;
+    getNextFlowNodesFor(flowNode: Model.Base.FlowNode): Array<Model.Base.FlowNode>;
+    getLaneForFlowNode(flowNodeId: string): Model.ProcessElements.Lane;
+    getLinkCatchEventsByLinkName(linkName: string): Array<Model.Events.IntermediateCatchEvent>;
+    getDataObjects(): Array<Model.ProcessElements.DataObject>;
+    getInputDataObjectReferences(): Array<Model.ProcessElements.DataObjectReference>;
+    getOutputDataObjectReferencesForFlowNode(flowNodeId: string): Array<Model.ProcessElements.DataObjectReference>;
+    protected filterFlowNodesByType<TFlowNode extends Model.Base.FlowNode>(type: BpmnType): Array<TFlowNode>;
+    private getDataObjectReferences;
+}

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

@@ -0,0 +1,2 @@
+export * from './ProcessModelFacade';
+export * from './SubProcessModelFacade';

package/dist/ProcessModel/ProcessModelParser/BpmnModelParser.d.ts

@@ -0,0 +1,5 @@
+import { Model } from '../Model/index';
+export declare class BpmnModelParser {
+    parseXmlToObjectModel(xml: string): Promise<Model.Definitions>;
+    private buildErrorMessage;
+}

package/dist/ProcessModel/ProcessModelParser/BpmnParserService.d.ts

@@ -0,0 +1,100 @@
+import { IIamService, Identity } from '../../DataModels/Iam/index';
+import { Model } from '../Model/index';
+/**
+ * Describes a ProcessDefinition, as it is stored in the repository.
+ */
+export declare class ProcessDefinitionRaw {
+    name: string;
+    hash: string;
+    xml: string;
+    createdBy?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * A service that parses, validates and filters ProcessDefinitions and ProcessModels.
+ */
+export declare class BpmnParserService {
+    private bpmnModelParser;
+    private definitionsCache;
+    private iamService;
+    constructor(iamService: IIamService);
+    /**
+     * Takes an XML string and parses it into an internal ProcessDefinition.
+     * The definition is then sanity checked, before being returned.
+     *
+     * @async
+     * @param   xml                       The ProcessDefinition's raw xml.
+     * @returns                           The parsed ProcessDefinition.
+     * @throws {UnprocessableEntityError} If the XML is invalid.
+     */
+    parseAndValidateDefinition(xml: string): Promise<Model.Definitions>;
+    /**
+     * Parses the given list of raw ProcessDefinitions into a list of usable ProcessDefinition objects.
+     *
+     * @async
+     * @param   definitionsRaw The list of raw ProcessDefintions.
+     * @returns                The list of parsed ProcessDefinitions.
+     */
+    parseProcessDefinitions(definitionsRaw: Array<ProcessDefinitionRaw>): Promise<Array<Model.Definitions>>;
+    /**
+     * Parses the given ProcessDefinition's xml into a usable ProcessDefinition object.
+     *
+     * @async
+     * @param  definitionRaw The raw ProcessDefinition to parse.
+     * @returns              The parsed ProcessDefinition object.
+     */
+    parseProcessDefinition(definitionRaw: ProcessDefinitionRaw): Promise<Model.Definitions>;
+    /**
+     * Gets the ProcessModel with the given ID from the given list of raw ProcessDefinitions.
+     *
+     * @async
+     * @param   definitionsRaw The list of raw ProcessDefinitions.
+     * @param   processModelId The ID of the ProcessModel to get.
+     * @returns                The retrieved ProcessModel.
+     * @throws {NotFoundError} If the ProcessModel was not found.
+     */
+    retrieveProcessModel(definitionsRaw: Array<ProcessDefinitionRaw>, processModelId: string): Promise<Model.Process>;
+    /**
+     * Parses the list of given raw ProcessDefinitions and gets a list of all ProcessModels contained in those definitions.
+     *
+     * @async
+     * @param   definitionsRaw The list of raw ProcessDefinitions.
+     * @returns                The list of parsed ProcessModels retrieved from the definitions.
+     */
+    getProcessModelList(definitionsRaw: Array<ProcessDefinitionRaw>): Promise<Array<Model.Process>>;
+    /**
+     * Takes a ProcessModel and an Identity and filters out all elements of the ProcessModel that the Identity is not allowed to access.
+     *
+     * @async
+     * @param   identity     The identity for which to filter out inaccessible elements.
+     * @param   processModel The ProcessModel to filter.
+     * @returns              The filtered ProcessModel, or "undefined", if the user is not allowed to access the ProcessModel at all.
+     */
+    filterInaccessibleProcessModelElements(identity: Identity, processModel: Model.Process): Promise<Model.Process>;
+    /**
+     * Takes a laneSet and filters out all lanes that the given identity is not allowed to access.
+     *
+     * @param   laneSet  The laneSet to filter.
+     * @param   identity The identity for which to filter the given laneSet.
+     * @returns          The filtered laneSet.
+     */
+    filterOutInaccessibleLanes(laneSet: Model.ProcessElements.LaneSet, identity: Identity): Promise<Model.ProcessElements.LaneSet>;
+    /**
+     * Compares a laneSet against a list of FlowNodes and returns all FlowNodes that are on any of the given lanes.
+     * Useful for determining which FlowNodes a user is allowed to access on a filtered laneSet.
+     *
+     * @param   laneSet   The laneSet to use as a baseline.
+     * @param   flowNodes The flowNodes to filter.
+     * @returns           The filtered FlowNodes.
+     */
+    getFlowNodesForLaneSet(laneSet: Model.ProcessElements.LaneSet, flowNodes: Array<Model.Base.FlowNode>): Array<Model.Base.FlowNode>;
+    /**
+     * Checks if the given ProcessModel has any StartEvents.
+     *
+     * @param   processModel The ProcessModel to check.
+     * @returns              True, if the ProcessModel has StartEvents; otherwise false.
+     */
+    checkIfProcessModelHasAccessibleStartEvents(processModel: Model.Process): boolean;
+    private checkifUserHasAdminPrivileges;
+}

package/dist/ProcessModel/ProcessModelParser/IConstructor.d.ts

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

package/dist/ProcessModel/ProcessModelParser/Parser/CollaborationParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../Model/index';
+export declare function parseCollaboration(parsedObjectModel: object): Model.Collaboration;

package/dist/ProcessModel/ProcessModelParser/Parser/DefinitionParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../Model/index';
+export declare function parseDefinitions(parsedXml: object): Model.Definitions;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../Model/index';
+export declare function parseProcessFlowNodes(processData: any, errors: Array<Model.GlobalElements.Error>, eventDefinitions: Array<Model.Events.Definitions.EventDefinition>): Array<Model.Base.FlowNode>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../Model/index';
+export declare function parseActivitiesFromProcessData(processData: any, errors: Array<Model.GlobalElements.Error>, eventDefinitions: Array<Model.Events.Definitions.EventDefinition>): Array<Model.Activities.Activity>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/ActivityFactory.d.ts

@@ -0,0 +1,3 @@
+import { Model } from '../../../../Model/index';
+import { IConstructor } from '../../../IConstructor';
+export declare function createActivityInstance<TActivity extends Model.Activities.Activity>(data: any, type: IConstructor<TActivity>): TActivity;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/BusinessRuleTaskParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseBusinessRuleTasks(processData: any): Array<Model.Activities.BusinessRuleTask>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/CallActivityParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseCallActivities(processData: any): Array<Model.Activities.CallActivity>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/EmptyActivityParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseEmptyActivities(processData: any): Array<Model.Activities.EmptyActivity>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/ExtensionPropertyParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function findExtensionPropertyByName(propertyName: string, extensionProperties: Array<Model.Base.Types.CamundaExtensionProperty>): Model.Base.Types.CamundaExtensionProperty;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/ManualTaskParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseManualTasks(processData: any): Array<Model.Activities.ManualTask>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/ReceiveTaskParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseReceiveTasks(processData: any, eventDefinitions: Array<Model.Events.Definitions.EventDefinition>): Array<Model.Activities.ReceiveTask>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/ScriptTaskParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseScriptTasks(processData: any): Array<Model.Activities.ScriptTask>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/SendTaskParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseSendTasks(processData: any, eventDefinitions: Array<Model.Events.Definitions.EventDefinition>): Array<Model.Activities.SendTask>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/ServiceTaskParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseServiceTasks(processData: any): Array<Model.Activities.ServiceTask>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/SubprocessParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseSubProcesses(processData: any, errors: Array<Model.GlobalElements.Error>, eventDefinitions: Array<Model.Events.Definitions.EventDefinition>): Array<Model.Activities.SubProcess>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/UserTaskParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../../Model/index';
+export declare function parseUserTasks(processData: any): Array<Model.Activities.UserTask>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/ActivityParsers/index.d.ts

@@ -0,0 +1,22 @@
+import * as businessRuleTaskParser from './BusinessRuleTaskParser';
+import * as callActivityParser from './CallActivityParser';
+import * as emptyActivityParser from './EmptyActivityParser';
+import * as manualTaskParser from './ManualTaskParser';
+import * as receiveTaskParser from './ReceiveTaskParser';
+import * as scriptTaskParser from './ScriptTaskParser';
+import * as sendTaskParser from './SendTaskParser';
+import * as serviceTaskParser from './ServiceTaskParser';
+import * as subProcessParser from './SubprocessParser';
+import * as userTaskParser from './UserTaskParser';
+export declare namespace ActivityParsers {
+    export import BusinessRuleTaskParser = businessRuleTaskParser;
+    export import CallActivityParser = callActivityParser;
+    export import EmptyActivityParser = emptyActivityParser;
+    export import ManualTaskParser = manualTaskParser;
+    export import ReceiveTaskParser = receiveTaskParser;
+    export import ScriptTaskParser = scriptTaskParser;
+    export import SendTaskParser = sendTaskParser;
+    export import ServiceTaskParser = serviceTaskParser;
+    export import SubProcessParser = subProcessParser;
+    export import UserTaskParser = userTaskParser;
+}

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/EventParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../Model/index';
+export declare function parseEventsFromProcessData(processData: any, parsedErrors: Array<Model.GlobalElements.Error>, parsedEventDefinitions: Array<Model.Events.Definitions.EventDefinition>): Array<Model.Events.Event>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/GatewayParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../../Model/index';
+export declare function parseGatewaysFromProcessData(processData: any): Array<Model.Gateways.Gateway>;

package/dist/ProcessModel/ProcessModelParser/Parser/FlowNodeParsers/index.d.ts

@@ -0,0 +1,8 @@
+import * as activityParser from './ActivityParser';
+import * as eventParser from './EventParser';
+import * as gatewayParser from './GatewayParser';
+export declare namespace FlowNodeParsers {
+    export import ActivityParser = activityParser;
+    export import EventParser = eventParser;
+    export import GatewayParser = gatewayParser;
+}

package/dist/ProcessModel/ProcessModelParser/Parser/MessageFlowParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../Model/index';
+export declare function parseMessageFlows(data: any): Array<Model.GlobalElements.MessageFlow>;

package/dist/ProcessModel/ProcessModelParser/Parser/ProcessLaneSetParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../Model/index';
+export declare function parseProcessLaneSet(data: any): Model.ProcessElements.LaneSet;

package/dist/ProcessModel/ProcessModelParser/Parser/ProcessParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../Model/index';
+export declare function parseProcesses(rawProcessDefinition: object, baseDefinition: Model.Definitions): Array<Model.Process>;

package/dist/ProcessModel/ProcessModelParser/Parser/SequenceFlowParser.d.ts

@@ -0,0 +1,2 @@
+import { Model } from '../../Model/index';
+export declare function parseProcessSequenceFlows(data: any): Array<Model.ProcessElements.SequenceFlow>;

package/dist/ProcessModel/ProcessModelParser/Parser/index.d.ts

@@ -0,0 +1,8 @@
+export * from './FlowNodeParsers/index';
+export * from './CollaborationParser';
+export * from './DefinitionParser';
+export * from './FlowNodeParser';
+export * from './MessageFlowParser';
+export * from './ProcessLaneSetParser';
+export * from './ProcessParser';
+export * from './SequenceFlowParser';

package/dist/ProcessModel/ProcessModelParser/TypeFactory.d.ts

@@ -0,0 +1,30 @@
+import { Model } from '../Model/index';
+import { IConstructor } from './IConstructor';
+/**
+ * Retrieves an element from the given raw ProcessModel data.
+ * Returns undefined, if the element does not exist.
+ *
+ * @param   rawProcessModel The raw ProcessModel from which to extract an element.
+ * @param   elementName     The name of the element to extract.
+ * @returns                 The extracted element, or undefined if it doesn't exist.
+ */
+export declare function getModelPropertyAsArray(rawProcessModel: any, elementName: string): Array<any>;
+/**
+ * Uses the given raw data to create an instance of one of our own ProcessModel elements.
+ * This can be any support element, like a Process, Collaboration, FlowNode, etc.
+ *
+ * @param   rawData    The raw data from which to create an instance.
+ * @param   targetType A type that matches one of our own ProcessModel elements.
+ * @returns            The created instance.
+ */
+export declare function createObjectWithCommonProperties<TTargetType extends Model.Base.BaseElement>(rawData: any, targetType: IConstructor<TTargetType>): TTargetType;
+/**
+ * Takes the given instance of one of our own ProcessModel elements and fills
+ * out all the properties that are common for every BPMN element
+ * (ID, documentation, etc), using the given raw data as a baseline.
+ *
+ * @param   rawData  The raw data from which to get the values.
+ * @param   instance The instance for which to set the common properties.
+ * @returns          The updated instance.
+ */
+export declare function setCommonObjectPropertiesFromData(rawData: any, instance: Model.Base.BaseElement): Model.Base.BaseElement;

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

@@ -0,0 +1,5 @@
+export * from './Parser/index';
+export * from './BpmnModelParser';
+export * from './BpmnParserService';
+export * from './IConstructor';
+export * from './TypeFactory';

package/dist/ProcessModel/ViewModel/Activities/ActivityViewModel.d.ts

@@ -0,0 +1,3 @@
+import { FlowNodeViewModel } from '../FlowNodeViewModel';
+export declare abstract class ActivityViewModel extends FlowNodeViewModel {
+}

package/dist/ProcessModel/ViewModel/Activities/BusinessRuleTaskViewModel.d.ts

@@ -0,0 +1,3 @@
+import { ActivityViewModel } from './ActivityViewModel';
+export declare class BusinessRuleTaskViewModel extends ActivityViewModel {
+}

package/dist/ProcessModel/ViewModel/Activities/CallActivityViewModel.d.ts

@@ -0,0 +1,9 @@
+import { CallActivity } from '../../Model/Activities/index';
+import { ProcessModelLike } from '../BaseElementViewModel';
+import { ActivityViewModel } from './ActivityViewModel';
+export declare class CallActivityViewModel extends ActivityViewModel {
+    processId?: string;
+    startEvent?: string;
+    payload?: any;
+    constructor(callActivity: CallActivity, processModel: ProcessModelLike);
+}