@5minds/processcube_engine_sdk 3.3.0

package/dist/DataModels/ProcessDefinition.d.ts

@@ -0,0 +1,177 @@
+import { EndEventViewModel, FlowNodeViewModel, Model, StartEventViewModel } from '../ProcessModel/index';
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessDefinition:
+ *       description: A ProcessDefinition.
+ *       type: object
+ *       required:
+ *         - processDefinitionId
+ *         - xml
+ *         - hash
+ *         - processModels
+ *         - deployedAt
+ *         - deployedByUserId
+ *       properties:
+ *         processDefinitionId:
+ *           description: The ID of the ProcessDefinition.
+ *           type: string
+ *         xml:
+ *           description: The XML of the ProcessDefinition.
+ *           type: string
+ *         hash:
+ *           description: The hash of the ProcessDefinition.
+ *           type: string
+ *         processModels:
+ *           description: The ProcessModels contained in the ProcessDefinition.
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/ProcessModel'
+ *         deployedAt:
+ *           description: The date when the ProcessDefinition was deployed.
+ *           type: string
+ *         deployedByUserId:
+ *           description: The ID of the user who deployed the ProcessDefinition.
+ *           type: string
+ */
+export declare type ProcessDefinition = {
+    processDefinitionId: string;
+    xml: string;
+    hash: string;
+    processModels: Array<ProcessModel>;
+    deployedAt: Date;
+    deployedByUserId: string;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessModel:
+ *       description: A ProcessModel.
+ *       type: object
+ *       required:
+ *         - processDefinitionId
+ *         - processModelId
+ *         - isExecutable
+ *         - startEvents
+ *         - endEvents
+ *         - flowNodes
+ *       properties:
+ *         processDefinitionId:
+ *           description: The ID of the ProcessDefinition that contains the ProcessModel.
+ *           type: string
+ *         processModelId:
+ *           description: The ID of the ProcessModel.
+ *           type: string
+ *         processModelName:
+ *           description: The name of the ProcessModel.
+ *           type: string
+ *         version:
+ *           description: The version of the ProcessModel.
+ *           type: string
+ *         isExecutable:
+ *           description: A flag indicating whether the ProcessModel can be started.
+ *           type: boolean
+ *         startEvents:
+ *           description: The StartEvents contained in the ProcessModel.
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/StartEventViewModel'
+ *         endEvents:
+ *           description: The EndEvents contained in the ProcessModel.
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/EndEventViewModel'
+ *         flowNodes:
+ *           description: The FlowNodes contained in the ProcessModel.
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/FlowNodeViewModel'
+ */
+export declare type ProcessModel = {
+    processDefinitionId: string;
+    processModelId: string;
+    processModelName?: string;
+    version?: string;
+    customProperties?: Record<string, any>;
+    isExecutable: boolean;
+    laneSet?: Model.ProcessElements.LaneSet;
+    startEvents: Array<StartEventViewModel>;
+    endEvents: Array<EndEventViewModel>;
+    flowNodes: Array<FlowNodeViewModel>;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessDefinitionList:
+ *       description: A list of ProcessDefinitions.
+ *       type: object
+ *       required:
+ *         - processDefinitions
+ *         - totalCount
+ *       properties:
+ *         processDefinitions:
+ *           description: The ProcessDefinitions.
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/ProcessDefinition'
+ *         totalCount:
+ *           description: The total number of ProcessDefinitions.
+ *           type: number
+ */
+export declare type ProcessDefinitionList = {
+    processDefinitions: Array<ProcessDefinition>;
+    totalCount: number;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessModelList:
+ *       description: A list of ProcessModels.
+ *       type: object
+ *       required:
+ *         - processModels
+ *         - totalCount
+ *       properties:
+ *         processModels:
+ *           description: The ProcessModels.
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/ProcessModel'
+ *         totalCount:
+ *           description: The total number of ProcessModels.
+ *           type: number
+ */
+export declare type ProcessModelList = {
+    processModels: Array<ProcessModel>;
+    totalCount: number;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     PersistProcessDefinitionsPayload:
+ *       description: The payload for persisting process definitions.
+ *       type: object
+ *       required:
+ *         - xml
+ *       properties:
+ *         xml:
+ *           description: The xml of the process definition(s) to persist.
+ *           oneOf:
+ *             - type: string
+ *             - type: array
+ *               items:
+ *                 type: string
+ *           example: string | string[]
+ *         overwriteExisting:
+ *           description: A flag indicating whether existing process definitions should be overwritten.
+ *           type: boolean
+ */
+export declare type PersistProcessDefinitionsPayload = {
+    xml: string | Array<string>;
+    overwriteExisting?: boolean;
+};

package/dist/DataModels/ProcessInstance/BpmnError.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This type can be used to throw an error modeled at an ErrorEndEvent.
+ */
+export declare class BpmnError extends Error {
+    code: number | string;
+    additionalInformation: any;
+    constructor(name: string, code?: number | string, message?: string, stackTrace?: string);
+}

package/dist/DataModels/ProcessInstance/ProcessInstance.d.ts

@@ -0,0 +1,192 @@
+import { Correlation } from '../Correlation';
+import { EventType } from '../../ProcessModel/index';
+import { FlowNodeInstance } from '../FlowNodeInstance';
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessInstanceList:
+ *       description: A list of ProcessInstances.
+ *       type: object
+ *       required:
+ *         - processInstances
+ *         - totalCount
+ *       properties:
+ *         processInstances:
+ *           description: The process instances
+ *           type: array
+ *           items:
+ *             $ref: '#/components/schemas/ProcessInstance'
+ *         totalCount:
+ *           description: The total number of process instances
+ *           type: number
+ */
+export declare type ProcessInstanceList = {
+    processInstances: Array<ProcessInstance>;
+    totalCount: number;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessInstance:
+ *       description: A ProcessInstance.
+ *       type: object
+ *       required:
+ *         - correlationId
+ *         - processInstanceId
+ *         - processDefinitionId
+ *         - processModelId
+ *         - hash
+ *         - state
+ *         - error
+ *         - ownerId
+ *         - startedByRootAccessToken
+ *       properties:
+ *         correlationId:
+ *           description: The id of the correlation in whichs context the process instance runs.
+ *           type: string
+ *         processInstanceId:
+ *           description: The id of the process instance.
+ *           type: string
+ *         processDefinitionId:
+ *           description: The id of the process definition which the process instance belongs to.
+ *           type: string
+ *         processModelId:
+ *           description: The id of the executed process model.
+ *           type: string
+ *         processModelName:
+ *           description: The name of the executed process model.
+ *           type: string
+ *         parentProcessInstanceId:
+ *           description: The id of the parent process instance, if this process instance is a sub process.
+ *           type: string
+ *         hash:
+ *           description: The hash of the used process model.
+ *           type: string
+ *         xml:
+ *           description: The xml of the used process model.
+ *           type: string
+ *         state:
+ *           description: The state of the process instance.
+ *           $ref: '#/components/schemas/ProcessInstanceState'
+ *         error:
+ *           description: The error that occured during execution of the process instance (if any).
+ *           type: object
+ *         ownerId:
+ *           description: The id of the user who started the process instance.
+ *           type: string
+ *         anonymousSessionId:
+ *           description: The id of the anonymous session that started the process instance (if any).
+ *           type: string
+ *         startedByRootAccessToken:
+ *           description: A flag indicating whether or not the process instance was started using a root access token.
+ *           type: boolean
+ *         createdAt:
+ *           description: The date when the process instance was started.
+ *           type: string
+ *         finishedAt:
+ *           description: The date when the process instance was finished.
+ *           type: string
+ *         restartedAt:
+ *           description: The date when the process instance was restarted (if any).
+ *           type: string
+ *         terminatedByUserId:
+ *           description: The id of the user who terminated the process instance (if any).
+ *           type: string
+ *         durationInMilliseconds:
+ *           description: The duration of the process instance in milliseconds.
+ *           type: number
+ *         startEventId:
+ *           description: The id of the start event that started the process instance.
+ *           type: string
+ *         startEventType:
+ *           description: The type of the start event that started the process instance.
+ *           $ref: '#/components/schemas/EventType'
+ *         startToken:
+ *           description: The token that was used to start the process instance
+ *           type: object
+ *         endEventId:
+ *           description: The id of the end event that ended the process instance (if ended).
+ *           type: string
+ *         endEventType:
+ *           description: The type of the end event that ended the process instance (if ended).
+ *           $ref: '#/components/schemas/EventType'
+ *         endToken:
+ *           description: The token that reached the end event (if ended).
+ *           type: object
+ *         metadata:
+ *           description: The metadata of the process instance.
+ *           $ref: '#/components/schemas/ProcessInstanceMetadata'
+ *         correlation:
+ *           description: The correlation in whichs context the process instance runs.
+ *           $ref: '#/components/schemas/Correlation'
+ *         triggeredByFlowNodeInstance:
+ *           description: The FlowNodeInstance that triggered the process instance (if any).
+ *           $ref: '#/components/schemas/FlowNodeInstance'
+ */
+export declare type ProcessInstance = {
+    correlationId: string;
+    processInstanceId: string;
+    processDefinitionId: string;
+    processModelId: string;
+    processModelName?: string;
+    parentProcessInstanceId?: string;
+    hash: string;
+    xml?: string;
+    state: ProcessInstanceState;
+    error: Error;
+    ownerId: string;
+    anonymousSessionId?: string;
+    startedByRootAccessToken: boolean;
+    createdAt?: Date;
+    finishedAt?: Date;
+    restartedAt?: Date;
+    terminatedByUserId?: string;
+    durationInMilliseconds?: number;
+    startEventId?: string;
+    startEventType?: EventType;
+    startToken?: any;
+    endEventId?: string;
+    endEventType?: EventType;
+    endToken?: any;
+    metadata?: ProcessInstanceMetadata;
+    correlation?: Correlation;
+    triggeredByFlowNodeInstance?: FlowNodeInstance;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessInstanceState:
+ *       description: The state of a ProcessInstance.
+ *       type: string
+ *       enum:
+ *         - running
+ *         - finished
+ *         - error
+ *         - terminated
+ */
+/**
+ * Lists the various states that a ProcessInstance can be in.
+ */
+export declare enum ProcessInstanceState {
+    running = "running",
+    finished = "finished",
+    error = "error",
+    terminated = "terminated"
+}
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessInstanceMetadata:
+ *       description: Metadata for a ProcessInstance.
+ *       type: object
+ */
+/**
+ * Describes a Metadata property of a ProcessInstance.
+ */
+export declare type ProcessInstanceMetadata = {
+    [key: string]: string;
+};

package/dist/DataModels/ProcessInstance/ProcessInstanceQuery.d.ts

@@ -0,0 +1,123 @@
+import { EventType } from '../../ProcessModel/index';
+import { ProcessInstanceState } from './ProcessInstance';
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     SearchQuery:
+ *       description: The query to use for a search.
+ *       type: object
+ *       required:
+ *         - operator
+ *         - searchParams
+ *       properties:
+ *         operator:
+ *           description: The operator to use for the search (or / and).
+ *           type: string
+ *         searchParams:
+ *           description: The search parameters to use for the search.
+ *           oneOf:
+ *           - type: array
+ *             items:
+ *               type: string
+ *           - type: array
+ *             items:
+ *               $ref: '#/components/schemas/SearchQuery'
+ *           - type: array
+ *             items:
+ *               $ref: '#/components/schemas/SearchParams'
+ */
+export type SearchQuery = {
+    operator: 'or' | 'and';
+    searchParams: Array<SearchParams> | Array<string> | Array<SearchQuery>;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     SearchParams:
+ *       description: The parameters to use for a search.
+ *       type: object
+ *       required:
+ *         - searchString
+ *       properties:
+ *         searchString:
+ *           description: The string to search for.
+ *           type: string
+ *         caseSensitive:
+ *           description: A flag to indicate, whether the search should be case sensitive.
+ *           type: boolean
+ *         partialMatch:
+ *           description: A flag to indicate, whether the search should be a partial match.
+ *           type: boolean
+ */
+export type SearchParams = {
+    searchString: string;
+    caseSensitive?: boolean;
+    partialMatch?: boolean;
+};
+export type ProcessInstanceQuery = {
+    correlationId?: Array<string> | string | SearchQuery;
+    processInstanceId?: Array<string> | string | SearchQuery;
+    processDefinitionId?: Array<string> | string | SearchQuery;
+    processModelId?: Array<string> | string | SearchQuery;
+    processModelName?: Array<string> | string | SearchQuery;
+    processModelHash?: Array<string> | string | SearchQuery;
+    ownerId?: Array<string> | string | SearchQuery;
+    startedByRootAccessToken?: boolean;
+    anonymousSessionId?: Array<string> | string | SearchQuery;
+    state?: Array<ProcessInstanceState> | ProcessInstanceState;
+    parentProcessInstanceId?: Array<string> | string | SearchQuery;
+    finishedAt?: Array<Date> | Date;
+    finishedBefore?: Date;
+    finishedAfter?: Date;
+    terminatedByUserId?: Array<string> | string | SearchQuery;
+    createdAt?: Array<Date> | Date;
+    createdBefore?: Date;
+    createdAfter?: Date;
+    updatedAt?: Array<Date> | Date;
+    updatedBefore?: Date;
+    updatedAfter?: Date;
+    durationInMillisecondsGreaterThan?: number;
+    durationInMillisecondsLessThan?: number;
+    startToken?: SearchQuery;
+    startEventId?: Array<string> | string | SearchQuery;
+    startEventType?: Array<EventType> | EventType;
+    endToken?: SearchQuery;
+    endEventId?: Array<string> | string | SearchQuery;
+    endEventType?: Array<EventType> | EventType;
+    correlationMetadata?: Array<string> | string | SearchQuery;
+    processInstanceMetadata?: Array<string> | string | SearchQuery;
+    triggeredByFlowNodeInstance?: Array<string> | string | SearchQuery;
+};
+export declare enum ProcessInstanceSortableColumns {
+    correlationId = "correlationId",
+    processInstanceId = "processInstanceId",
+    processDefinitionId = "processDefinitionId",
+    processModelId = "processModelId",
+    processModelName = "processModelName",
+    processModelHash = "processModelHash",
+    ownerId = "ownerId",
+    startedByRootAccessToken = "startedByRootAccessToken",
+    state = "state",
+    error = "error",
+    parentProcessInstanceId = "parentProcessInstanceId",
+    finishedAt = "finishedAt",
+    terminatedByUserId = "terminatedByUserId",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt",
+    durationInMilliseconds = "durationInMilliseconds",
+    startToken = "startToken",
+    startEventId = "startEventId",
+    startEventType = "startEventType",
+    endToken = "endToken",
+    endEventId = "endEventId",
+    endEventType = "endEventType",
+    correlationMetadata = "correlationMetadata",
+    processInstanceMetadata = "processInstanceMetadata",
+    triggeredByFlowNodeInstance = "triggeredByFlowNodeInstance"
+}
+export type ProcessInstanceSortSettings = {
+    sortBy: ProcessInstanceSortableColumns;
+    sortDir?: 'ASC' | 'DESC';
+};

package/dist/DataModels/ProcessInstance/ProcessStartOptions.d.ts

@@ -0,0 +1,118 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     StartCallbackType:
+ *       description: The type of callback to use for a ProcessInstance start.
+ *       type: integer
+ *       oneOf:
+ *       - title: CallbackOnProcessInstanceCreated
+ *         const: 1
+ *         description: The Engine will resolve immediately after the ProcessInstance was started.
+ *       - title: CallbackOnProcessInstanceFinished
+ *         const: 2
+ *         description: The Engine will resolve after the first EndEvent was reached.
+ *       - title: CallbackOnEndEventReached
+ *         const: 3
+ *         description: The Engine will resolve after a specific EndEvent was reached.
+ */
+/**
+ * Determines when the Engine will resolve after a new ProcessInstance was started.
+ */
+export declare enum StartCallbackType {
+    /**
+     * The Engine will resolve immediately after the ProcessInstance was started.
+     */
+    CallbackOnProcessInstanceCreated = 1,
+    /**
+     * The Engine will resolve after the first EndEvent was reached.
+     */
+    CallbackOnProcessInstanceFinished = 2,
+    /**
+     * The Engine will resolve after a specific EndEvent was reached.
+     */
+    CallbackOnEndEventReached = 3
+}
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessStartOptions:
+ *       description: The options to use for starting a ProcessInstance.
+ *       type: object
+ *       required:
+ *         - processModelId
+ *       properties:
+ *         processModelId:
+ *           description: The ID of the ProcessModel to start.
+ *           type: string
+ *         startEventId:
+ *           description: The ID of a StartEvent at which the ProcessInstance should start.
+ *           type: string
+ *         correlationId:
+ *           description: A correlation ID to use for the ProcessInstance.
+ *           type: string
+ *         initialToken:
+ *           description: The token to use for an initial ProcessToken.
+ *           type: object
+ */
+/**
+ * Contains configurable options for starting a ProcessInstance with a client interface.
+ */
+export declare type ProcessStartOptions<TToken extends Record<string, any>> = {
+    /**
+     * The ID of the ProcessModel to start.
+     */
+    processModelId: string;
+    /**
+     * The ID of a StartEvent at which the ProcessInstance should start.
+     * Must be provided, if the ProcessModel has multiple StartEvents,
+     * but is optional, if the ProcessModel only has one.
+     */
+    startEventId?: string;
+    /**
+     * The ID of a correlation to which the ProcessInstance should belong.
+     * Default is an auto-generated uuid.
+     */
+    correlationId?: string;
+    /**
+     * A set of values to use for an initial ProcessToken.
+     */
+    initialToken?: TToken;
+};
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessStartRequest:
+ *       description: The request object to use for starting a ProcessInstance.
+ *       allOf:
+ *         - $ref: '#/components/schemas/ProcessStartOptions'
+ *         - type: object
+ *           properties:
+ *             returnOn:
+ *               description: |
+ *                 Determines when the Engine will resolve, after a new request for starting a ProcessInstance was made.
+ *                 Note: If "CallbackOnEndEventReached" is selected, "endEventId" is no longer optional!
+ *               $ref: '#/components/schemas/StartCallbackType'
+ *             endEventId:
+ *               description: The ID of an EndEvent that should be awaited. Must be provided, of "returnOn" is set to "CallbackOnEndEventReached".
+ *               type: string
+ */
+/**
+ * Contains configurable options for starting a ProcessInstance.
+ */
+export declare type ProcessStartRequest<TToken extends Record<string, any>> = ProcessStartOptions<TToken> & {
+    /**
+     * Determines when the Engine will resolve, after a new request for starting a ProcessInstance was made.
+     *
+     * Note:
+     * If "CallbackOnEndEventReached" is selected, "endEventId" is no longer optional!
+     */
+    returnOn?: StartCallbackType;
+    /**
+     * The ID of an EndEvent that should be awaited.
+     * Must be provided, of "returnOn" is set to "CallbackOnEndEventReached".
+     */
+    endEventId?: string;
+};

package/dist/DataModels/ProcessInstance/ProcessStartResponse.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ProcessStartResponse:
+ *       description: |
+ *         Contains a response from the Engine, which will be send after a ProcessInstance was started.
+ *         Depending on the type of start callback used, this will also contain information about the reached EndEvent.
+ *       type: object
+ *       required:
+ *         - processInstanceId
+ *         - correlationId
+ *       properties:
+ *         processInstanceId:
+ *           description: The ID of the ProcessInstance.
+ *           type: string
+ *         correlationId:
+ *           description: The ID of the Correlation in which the started ProcessInstance runs.
+ *           type: string
+ *         endEventId:
+ *           description: If the Engine is set to wait for the ProcessInstance to finish, this will contain the ID of the EndEvent with which ProcessInstance was finished.
+ *           type: string
+ *         tokenPayload:
+ *           description: If the Engine is set to wait for the ProcessInstance to finish, this will contain the final result with which ProcessInstance was finished.
+ *           type: object
+ */
+/**
+ * Contains a response from the Engine, which will be send after a ProcessInstance was started.
+ * Depending on the type of start callback used, this will also contain information about the reached EndEvent.
+ */
+export declare type ProcessStartResponse = {
+    /**
+     * The ID of the ProcessInstance.
+     */
+    processInstanceId: string;
+    /**
+     * The ID of the Correlation in which the started ProcessInstance runs.
+     */
+    correlationId: string;
+    /**
+     * Optional: If the Engine is set to wait for the ProcessInstance to finish,
+     * this will contain the ID of the EndEvent with which ProcessInstance was finished.
+     */
+    endEventId?: string;
+    /**
+     * Optional: If the Engine is set to wait for the ProcessInstance to finish,
+     * this will contain the final result with which ProcessInstance was finished.
+     */
+    tokenPayload?: any;
+};

package/dist/DataModels/ProcessInstance/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BpmnError';
+export * from './ProcessInstance';
+export * from './ProcessInstanceQuery';
+export * from './ProcessStartOptions';
+export * from './ProcessStartResponse';