@5minds/processcube_engine_sdk 3.3.0

package/dist/ExtensionAdapter/ProcessInstanceExtensionAdapter.d.ts

@@ -0,0 +1,20 @@
+import { DataModels, Identity } from '../index';
+export interface IProcessInstanceExtensionAdapter {
+    query(query: DataModels.ProcessInstances.ProcessInstanceQuery, options?: {
+        identity?: Identity;
+        includeXml?: boolean;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.ProcessInstances.ProcessInstanceSortSettings;
+    }): Promise<DataModels.ProcessInstances.ProcessInstanceList>;
+    getProcessDefinition(processInstanceId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessDefinition>;
+    getProcessModel(processInstanceId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    transferOwnership(processInstanceId: string, newOwner: Identity, identity?: Identity): Promise<void>;
+    terminateProcessInstance(processInstanceId: string, identity?: Identity): Promise<void>;
+    retryProcessInstance(processInstanceId: string, options?: {
+        flowNodeInstanceId?: string;
+        newStartToken?: any;
+        identity?: Identity;
+    }): Promise<void>;
+    deleteProcessInstances(processInstanceIds: Array<string>, deleteAllRelatedData: boolean, identity?: Identity): Promise<void>;
+}

package/dist/ExtensionAdapter/ProcessModelExtensionAdapter.d.ts

@@ -0,0 +1,28 @@
+import { DataModels, Identity } from '../index';
+type ProcessStartOptions<TPayload extends object> = DataModels.ProcessInstances.ProcessStartOptions<TPayload>;
+type ProcessStartResponse = DataModels.ProcessInstances.ProcessStartResponse;
+export interface IProcessModelExtensionAdapter {
+    getAll(options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+    }): Promise<DataModels.ProcessDefinitions.ProcessModelList>;
+    getById(processModelId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    getByProcessInstanceId(processInstanceId: string, identity?: Identity): Promise<DataModels.ProcessDefinitions.ProcessModel>;
+    startProcessInstance<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitEndEvent<TPayload extends object>(options: ProcessStartOptions<TPayload>, identity?: Identity): Promise<ProcessStartResponse>;
+    startProcessInstanceAndAwaitSpecificEndEvent<TPayload extends object>(options: DataModels.ProcessInstances.ProcessStartOptions<TPayload>, endEventId: string, identity?: Identity): Promise<ProcessStartResponse>;
+    /**
+     * @param deleteAllRelatedData Optional: If set to true, the Process Definition, as well as all related data, will be completely deleted.
+     *                             Otherwise, the Process Definition will only be flagged as deleted, but all data will be kept.
+     *                             Note that this won't do anything on engines with a version below v13.0.7.
+     */
+    deleteDefinitionByProcessModelId(processModelId: string, options?: {
+        force?: boolean;
+        identity?: Identity;
+        deleteAllRelatedData?: boolean;
+    }): Promise<void>;
+    enableProcessModel(processModelId: string, identity?: Identity): Promise<void>;
+    disableProcessModel(processModelId: string, identity?: Identity): Promise<void>;
+}
+export {};

package/dist/ExtensionAdapter/UserTaskExtensionAdapter.d.ts

@@ -0,0 +1,31 @@
+import { DataModels, Identity, Messages, Subscription } from '../index';
+type UserTaskList = DataModels.FlowNodeInstances.UserTaskList;
+export interface IUserTaskExtensionAdapter {
+    query(query: DataModels.FlowNodeInstances.UserTaskQuery, options?: {
+        identity?: Identity;
+        offset?: number;
+        limit?: number;
+        sortSettings?: DataModels.FlowNodeInstances.FlowNodeInstanceSortSettings;
+    }): Promise<UserTaskList>;
+    reserveUserTaskInstance(identity: Identity, flowNodeInstanceId: string, actualOwnerId: string): Promise<void>;
+    cancelUserTaskInstanceReservation(identity: Identity, flowNodeInstanceId: string): Promise<void>;
+    finishUserTask(userTaskInstanceId: string, userTaskResult: DataModels.FlowNodeInstances.UserTaskResult, identity?: Identity): Promise<void>;
+    onUserTaskWaiting(callback: Messages.CallbackTypes.OnUserTaskWaitingCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskFinished(callback: Messages.CallbackTypes.OnUserTaskFinishedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskReserved(callback: Messages.CallbackTypes.OnUserTaskReservedCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    onUserTaskReservationCanceled(callback: Messages.CallbackTypes.OnUserTaskReservationCanceledCallback, options?: {
+        subscribeOnce?: boolean;
+        identity?: Identity;
+    }): Promise<Subscription>;
+    removeSubscription(subscription: Subscription, identity?: Identity): void;
+}
+export {};

package/dist/ExtensionAdapter/index.d.ts

@@ -0,0 +1,16 @@
+export * from './AnonymousSessionExtensionAdapter';
+export * from './ApplicationInfoExtensionAdapter';
+export * from './CorrelationExtensionAdapter';
+export * from './CronjobExtensionAdapter';
+export * from './DataObjectInstanceExtensionAdapter';
+export * from './EmptyActivityExtensionAdapter';
+export * from './EventExtensionAdapter';
+export * from './ExternalTaskExtensionAdapter';
+export * from './FlowNodeInstanceExtensionAdapter';
+export * from './IIamExtensionAdapter';
+export * from './ManualTaskExtensionAdapter';
+export * from './NotificationExtensionAdapter';
+export * from './ProcessDefinitionExtensionAdapter';
+export * from './ProcessModelExtensionAdapter';
+export * from './ProcessInstanceExtensionAdapter';
+export * from './UserTaskExtensionAdapter';

package/dist/Logger.d.ts

@@ -0,0 +1,38 @@
+import { LogLevel } from './EngineEvents/EngineEvent';
+export type LogObject = {
+    flowNodeId?: string;
+    correlationId?: string;
+    processInstanceId?: string;
+    flowNodeInstanceId?: string;
+} & {
+    [key: string]: any;
+};
+export type LoggerSettings = {
+    minLogLevel: LogLevel;
+    engineId: string;
+    hostname?: string;
+};
+export declare function initLogger(settings: LoggerSettings): void;
+export declare function setGlobalLogObjects(logObjects: {
+    [key: string]: any;
+}): void;
+export declare function getGlobalLogObjects(): {
+    [key: string]: any;
+};
+export declare function setMinLogLevel(minLogLevelToSet: LogLevel): void;
+export declare class Logger {
+    private namespace;
+    private defaultLogObject;
+    constructor(namespace: string, defaultLogObject?: LogObject);
+    flush(): void;
+    addToDefaultLogObject(key: string, value: any): void;
+    removeFromDefaultLogObject(key: string): void;
+    logForLevel(message: string, level: LogLevel, logObject?: LogObject): void;
+    error(message: string, logObject?: LogObject): void;
+    warn(message: string, logObject?: LogObject): void;
+    info(message: string, logObject?: LogObject): void;
+    debug(message: string, logObject?: LogObject): void;
+    trace(message: string, logObject?: LogObject): void;
+    private shouldLog;
+    private logLevelAsNumber;
+}

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

@@ -0,0 +1,6 @@
+import { FlowNode } from '../Base/index';
+/**
+ * The base class for all activities.
+ */
+export declare abstract class Activity extends FlowNode {
+}

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

@@ -0,0 +1,13 @@
+import { BpmnType } from '../Constants';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BusinessRuleTask.
+ *
+ * Note that the engine does not yet support these!
+ */
+export declare class BusinessRuleTask extends Activity {
+    get bpmnType(): BpmnType;
+    decisionRef: string;
+    decisionRefBinding: string;
+    decisionRefVersion: string;
+}

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

@@ -0,0 +1,56 @@
+import { BpmnType } from '../Constants';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN CallActivity.
+ *
+ * CallActivities also describe a type of subprocess, except that the process
+ * is not contained within the parent process, but is located somewhere else.
+ *
+ * This means that the process called by the CallActivity can also run by itself,
+ * unlike the subprocess contained within the 'SubProcess' Activity.
+ */
+export declare class CallActivity extends Activity {
+    get bpmnType(): BpmnType;
+    type: CallActivityType;
+    calledReference?: string;
+    /**
+     * Optional: The ID of the StartEvent with which to call the CallActivity.
+     * If no ID is provided, the first found StartEventID is used.
+     */
+    startEventId?: string;
+    /**
+     * Optional: The payload with which to start the CallActivity.
+     * 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/EmptyActivity.d.ts

@@ -0,0 +1,11 @@
+import { BpmnType } from '../Constants';
+import { FlowNode } from '../Base/index';
+/**
+ * Contains a blank activity that has no dedicated UseCase.
+ *
+ * Technically, this services as a Breakpoint for the Frontend.
+ */
+export declare class EmptyActivity extends FlowNode {
+    get bpmnType(): BpmnType;
+    enabled: boolean;
+}

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

@@ -0,0 +1,11 @@
+import { BpmnType } from '../Constants';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN ManualTask.
+ *
+ * Currently not evaluated during runtime.
+ */
+export declare class ManualTask extends Activity {
+    get bpmnType(): BpmnType;
+    requiresConfirmation: boolean;
+}

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

@@ -0,0 +1,17 @@
+import { BpmnType } from '../Constants';
+import { MessageEventDefinition } from '../Events/index';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN ReceiveTask.
+ *
+ * A ReceiveTask is used to wait for a message send by a SendTask.
+ *
+ * In contrast to an Intermediate Message Catch Event, a ReceiveTask will send an acknowledgement back to the SendTask that send the message.
+ */
+export declare class ReceiveTask extends Activity {
+    get bpmnType(): BpmnType;
+    /**
+     * This is the user defined Message which is expected by this ReceiveTask.
+     */
+    messageEventDefinition: MessageEventDefinition;
+}

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

@@ -0,0 +1,13 @@
+import { BpmnType } from '../Constants';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN ScriptTask.
+ *
+ * This type of task is used to execute JS code snippets.
+ */
+export declare class ScriptTask extends Activity {
+    get bpmnType(): BpmnType;
+    scriptFormat: string;
+    script: string;
+    resultVariable: string;
+}

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

@@ -0,0 +1,32 @@
+import { BpmnType } from '../Constants';
+import { MessageEventDefinition } from '../Events/index';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN SendTask.
+ *
+ * A SendTask sends a message to a ReceiveTask.
+ *
+ * In contrast to an Intermediate Message Throw Event, a SendTask will pause until it receives a response from a Receive Task.
+ */
+export declare class SendTask extends Activity {
+    get bpmnType(): BpmnType;
+    /**
+     * The message that should be send.
+    ‚ */
+    messageEventDefinition: MessageEventDefinition;
+    /**
+     * Optional: The interval in which a SendTask should re-send its message.
+     * Defaults to 500ms.
+     */
+    retryIntervalInMs: number;
+    /**
+     * Optional: The maximum number of retries.
+     * If not set, the SendTask will keep sending its message indefinetly, until it receives a response.
+     */
+    maxRetries?: number;
+    /**
+     * Optional: The payload to use.
+     * If not provided, the current token is used as a payload.
+     */
+    payload?: any;
+}

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

@@ -0,0 +1,56 @@
+import { BpmnType } from '../Constants';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN ServiceTask.
+ * A ServiceTask is used to call either a function from a specific class,
+ * or for performing web requests.
+ */
+export declare class ServiceTask extends Activity {
+    get bpmnType(): BpmnType;
+    /**
+     * The invocation to be used when the ServiceTask is called.
+     */
+    invocation: Invocation;
+    /**
+     * The ServiceTasks type.
+     * Currently only supports 'external' and 'internal'.
+     */
+    type: ServiceTaskType;
+    /**
+     * The topic to use in conjunction with external ServiceTasks.
+     */
+    topic?: string;
+    /**
+     * The payload to use in conjunction with external ServiceTasks.
+     */
+    payload?: string;
+    /**
+     * If set to 'true', the Service Task will fail, if it is not processed after the first lock ends.
+     */
+    isSingleTry?: boolean;
+    /**
+     * The type of ServiceTask. Determines how the ServiceTask is processed.
+     */
+    customType?: string;
+}
+/**
+ * Describes all currently supported ServiceTask types.
+ */
+export declare enum ServiceTaskType {
+    external = "external",
+    internal = "internal"
+}
+/**
+ * The base class for all invocation types.
+ */
+export declare abstract class Invocation {
+}
+/**
+ * Used by ServiceTasks.
+ * This contains the definition for a method invocation.
+ */
+export declare class MethodInvocation extends Invocation {
+    module: string;
+    method: string;
+    params: string;
+}

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

@@ -0,0 +1,20 @@
+import { BpmnType } from '../Constants';
+import { FlowNode } from '../Base/index';
+import { Association, DataObject, DataObjectReference, DataStoreReference, LaneSet, SequenceFlow } from '../ProcessElements/index';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN Subprocess.
+ *
+ * Technically they work like normal processes, except that they exist only
+ * within another process and are treated like an activity for that process.
+ */
+export declare class SubProcess extends Activity {
+    get bpmnType(): BpmnType;
+    laneSet?: LaneSet;
+    flowNodes: Array<FlowNode>;
+    sequenceFlows: Array<SequenceFlow>;
+    associations: Array<Association>;
+    dataStoreReferences: Array<DataStoreReference>;
+    dataObjectReferences: Array<DataObjectReference>;
+    dataObjects: Array<DataObject>;
+}

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

@@ -0,0 +1,67 @@
+import { BpmnType } from '../Constants';
+import { Activity } from './ActivityBase';
+/**
+ * Describes a BPMN UserTask.
+ *
+ * A user task will hold the current execution of the process and wait for user input
+ * before continuing.
+ */
+export declare class UserTask extends Activity {
+    get bpmnType(): BpmnType;
+    customForm?: string;
+    assignee: string;
+    candidateUsers: string;
+    candidateGroups: string;
+    dueDate?: Date;
+    followUpDate?: Date;
+    assignedUsersConfig?: string;
+    formFields: Array<UserTaskFormField>;
+    description: string;
+    finishedMessage: string;
+}
+/**
+ * Describes a BPMN FormField.
+ * A FormField is part of a UserTask and can contain all kinds of values.
+ *
+ * These values can then be used to finish the UserTask.
+ */
+export declare class UserTaskFormField {
+    /**
+     * The UserTasks unique identifier.
+     */
+    id: string;
+    /**
+     * The UserTasks label.
+     * This is the field that will be used to describe the FormField,
+     * when the UserTask is reached during ProcessModel execution.
+     */
+    label: string;
+    /**
+     * The type of the FormField.
+     * Can be virtually anything; string, boolean, number, or enum.
+     */
+    type: string;
+    /**
+     * The default value of the FormField.
+     */
+    defaultValue: string;
+    /**
+     * If the type of the FormField is set to 'enum',
+     * this will contain all possible enum values.
+     */
+    enumValues?: Array<FormFieldEnumValue>;
+    /**
+     * Determines the preferred type of control to use with the FormField.
+     * For instance, when using string, this will most likely be 'TextBox', or
+     * something similar.
+     */
+    customForm?: string;
+}
+/**
+ * Used in combination with 'enum' type UserTask FormFields,
+ * this describes a single enum value of that FormField.
+ */
+export declare class FormFieldEnumValue {
+    id: string;
+    name: string;
+}

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

@@ -0,0 +1,21 @@
+import * as serviceTaskInvocations from './ServiceTask';
+import * as userTaskTypes from './UserTask';
+export * from './ActivityBase';
+export * from './BusinessRuleTask';
+export * from './CallActivity';
+export * from './EmptyActivity';
+export * from './ManualTask';
+export * from './ReceiveTask';
+export * from './ScriptTask';
+export * from './SendTask';
+export * from './ServiceTask';
+export * from './SubProcess';
+export * from './UserTask';
+export declare namespace Invocations {
+    export import Invocation = serviceTaskInvocations.Invocation;
+    export import MethodInvocation = serviceTaskInvocations.MethodInvocation;
+}
+export declare namespace Types {
+    export import FormFieldEnumValue = userTaskTypes.FormFieldEnumValue;
+    export import UserTaskFormField = userTaskTypes.UserTaskFormField;
+}

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

@@ -0,0 +1,9 @@
+import { ExtensionElements } from './ExtensionElements';
+/**
+ * The base class for all BPMN elements, including processes, participants, etc.
+ */
+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

@@ -0,0 +1,19 @@
+import { BaseElement } from './BaseElement';
+/**
+ * Contains a BPMN DataInputAssociation.
+ * These associations signify that a FlowNode requires data from a DataObject or DataStore.
+ */
+export declare class DataInputAssociation extends BaseElement {
+    /**
+     * The given name of the DataInputAssociation.
+     */
+    name?: string;
+    /**
+     * The ID of the DataObject or DataStore from which to gather data.
+     */
+    sourceRef: string;
+    /**
+     * The ID of the FlowNode that requires data from the DataObject or DataStore.
+     */
+    targetRef: string;
+}

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

@@ -0,0 +1,23 @@
+import { BaseElement } from './BaseElement';
+/**
+ * Contains a BPMN DataOutputAssociation.
+ * These associations signify that a FlowNode writes data into a DataObject or DataStore.
+ */
+export declare class DataOutputAssociation extends BaseElement {
+    /**
+     * The given name of the DataOutputAssociation.
+     */
+    name?: string;
+    /**
+     * The ID of the FlowNode that writes data into the DataObject or DataStore.
+     */
+    sourceRef: string;
+    /**
+     * The ID of the DataObject or DataStore that the FlowNode writes to.
+     */
+    targetRef: string;
+    /**
+     * 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

@@ -0,0 +1,12 @@
+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>;
+}

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

@@ -0,0 +1,37 @@
+import { BpmnType } from '../Constants';
+import { BaseElement, DataInputAssociation, DataOutputAssociation } from '.';
+/**
+ * Base class for all FlowNodes.
+ * These include Events, Gateways and Activities.
+ */
+export declare abstract class FlowNode extends BaseElement {
+    name: string;
+    defaultOutgoingSequenceFlowId?: string;
+    /**
+     * A list of all incoming sequence flow IDs.
+     */
+    incoming: Array<string>;
+    /**
+     * A list of all outgoing sequence flow IDs.
+     */
+    outgoing: Array<string>;
+    /**
+     * A list of all DataInputAssociations.
+     * DataInputAssociations point to a DataStore or DataSource that the FlowNode requires data from.
+     */
+    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>;
+    /**
+     * The script that is run before the FlowNode starts execution.
+     */
+    preScript?: string;
+    /**
+     * The script that is run after the FlowNode has finished execution.
+     */
+    postScript?: string;
+    abstract readonly bpmnType: BpmnType;
+}

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

@@ -0,0 +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;
+}