bpmn-elements 9.1.2 → 9.2.0

package/CHANGELOG.md

@@ -1,6 +1,15 @@
 Changelog
 =========
 
+# 9.2.0
+
+- move outbound sequence flow evaluation logic from activity to sequence flow, where it belongs
+- spread sequence flow evaluation result, if object, to sequence flow take message
+
+# 9.1.3
+
+- type declare execution scope
+
 # 9.1.2
 
 - allow type IScripts.register to return undefined

package/dist/activity/Activity.js

@@ -837,10 +837,12 @@ Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content
   for (const outboundFlow of outboundList) {
     const {
       id: flowId,
-      action
+      action,
+      result
     } = outboundFlow;
     this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
       flow: {
+        ...(result && typeof result === 'object' && result),
         ...outboundFlow,
         sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
         ...(discardSequence && {
@@ -1027,26 +1029,11 @@ OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, messa
 };
 OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
   const broker = this.broker;
-  if (flow.isDefault) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {
-      action: 'take'
-    }), {
-      persistent: false
-    });
-  }
-  const flowCondition = flow.getCondition();
-  if (!flowCondition) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {
-      action: 'take'
-    }), {
-      persistent: false
-    });
-  }
   const {
     fromMessage,
     evaluationId
   } = this.evaluateArgs;
-  flowCondition.execute((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
+  flow.evaluate((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
     if (err) return this.completed(err);
     const action = result ? 'take' : 'discard';
     return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {

package/dist/flows/SequenceFlow.js

@@ -124,7 +124,7 @@ SequenceFlow.prototype.shake = function shake(message) {
     persistent: false,
     type: 'shake'
   });
-  for (const s of message.content.sequence) {
+  for (const s of message.content.sequence || []) {
     if (s.id === this.id) return this.broker.publish('event', 'flow.shake.loop', content, {
       persistent: false,
       type: 'shake'
@@ -164,6 +164,16 @@ SequenceFlow.prototype.createMessage = function createMessage(override) {
     parent: (0, _messageHelper.cloneParent)(this.parent)
   };
 };
+SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
+  if (this.isDefault) {
+    return callback(null, true);
+  }
+  const flowCondition = this.getCondition();
+  if (!flowCondition) {
+    return callback(null, true);
+  }
+  flowCondition.execute(fromMessage, callback);
+};
 SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this.createMessage({
     action,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "9.1.2",
+  "version": "9.2.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "type": "module",
   "main": "dist/index.js",
@@ -55,7 +55,7 @@
     "chai": "^4.3.7",
     "chronokinesis": "^5.0.2",
     "debug": "^4.3.4",
-    "eslint": "^8.38.0",
+    "eslint": "^8.39.0",
     "eslint-plugin-import": "^2.27.5",
     "got": "^12.6.0",
     "mocha": "^10.1.0",

package/src/activity/Activity.js

@@ -807,9 +807,10 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
 
 Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
   for (const outboundFlow of outboundList) {
-    const {id: flowId, action} = outboundFlow;
+    const {id: flowId, action, result} = outboundFlow;
     this.broker.publish('run', 'run.outbound.' + action, cloneContent(content, {
       flow: {
+        ...(result && typeof result === 'object' && result),
         ...outboundFlow,
         sequenceId: getUniqueId(`${flowId}_${action}`),
         ...(discardSequence && {discardSequence: discardSequence.slice()}),
@@ -1000,17 +1001,8 @@ OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, messa
 
 OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
   const broker = this.broker;
-  if (flow.isDefault) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
-  }
-
-  const flowCondition = flow.getCondition();
-  if (!flowCondition) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
-  }
-
   const {fromMessage, evaluationId} = this.evaluateArgs;
-  flowCondition.execute(cloneMessage(fromMessage), (err, result) => {
+  flow.evaluate(cloneMessage(fromMessage), (err, result) => {
     if (err) return this.completed(err);
     const action = result ? 'take' : 'discard';
     return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {

package/src/flows/SequenceFlow.js

@@ -101,7 +101,7 @@ SequenceFlow.prototype.shake = function shake(message) {
 
   if (content.id === this.targetId) return this.broker.publish('event', 'flow.shake.loop', content, {persistent: false, type: 'shake'});
 
-  for (const s of message.content.sequence) {
+  for (const s of message.content.sequence || []) {
     if (s.id === this.id) return this.broker.publish('event', 'flow.shake.loop', content, {persistent: false, type: 'shake'});
   }
 
@@ -140,6 +140,19 @@ SequenceFlow.prototype.createMessage = function createMessage(override) {
   };
 };
 
+SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
+  if (this.isDefault) {
+    return callback(null, true);
+  }
+
+  const flowCondition = this.getCondition();
+  if (!flowCondition) {
+    return callback(null, true);
+  }
+
+  flowCondition.execute(fromMessage, callback);
+};
+
 SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this.createMessage({
     action,

package/src/tasks/ReceiveTask.js

@@ -1,215 +1,215 @@
-import Activity from '../activity/Activity.js';
-import {cloneContent} from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kReferenceElement = Symbol.for('referenceElement');
-const kReferenceInfo = Symbol.for('referenceInfo');
-
-export default function ReceiveTask(activityDef, context) {
-  const task = new Activity(ReceiveTaskBehaviour, activityDef, context);
-
-  task.broker.assertQueue('message', {autoDelete: false, durable: true});
-  task.broker.bindQueue('message', 'api', '*.message.#', {durable: true});
-
-  return task;
-}
-
-export function ReceiveTaskBehaviour(activity) {
-  const {id, type, behaviour} = activity;
-
-  this.id = id;
-  this.type = type;
-
-  const reference = this.reference = {
-    name: 'anonymous',
-    ...behaviour.messageRef,
-    referenceType: 'message',
-  };
-
-  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-  this.activity = activity;
-  this.broker = activity.broker;
-
-  this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
-}
-
-ReceiveTaskBehaviour.prototype.execute = function execute(executeMessage) {
-  return new ReceiveTaskExecution(this).execute(executeMessage);
-};
-
-function ReceiveTaskExecution(parent) {
-  const {activity, broker, loopCharacteristics, reference} = parent;
-
-  this.id = activity.id;
-  this.logger = activity.logger;
-  this.reference = reference;
-  this.broker = broker;
-  this.loopCharacteristics = loopCharacteristics;
-  this.referenceElement = parent[kReferenceElement];
-
-  this[kCompleted] = false;
-}
-
-ReceiveTaskExecution.prototype.execute = function execute(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-
-  const executeContent = executeMessage.content;
-  const {executionId, isRootScope} = executeContent;
-  this.executionId = executionId;
-
-  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
-
-  if (isRootScope) {
-    this._setupMessageHandling(executionId);
-  }
-
-  const loopCharacteristics = this.loopCharacteristics;
-  if (loopCharacteristics && executeMessage.content.isRootScope) {
-    return loopCharacteristics.execute(executeMessage);
-  }
-
-  const broker = this.broker;
-  broker.consume('message', this._onCatchMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_onmessage-${executionId}`,
-  });
-
-  if (this[kCompleted]) return;
-
-  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_api-${executionId}`,
-    priority: 400,
-  });
-
-  this._debug(`expect ${info.description}`);
-
-  broker.publish('event', 'activity.wait', cloneContent(executeContent, {message: {...info.message}}));
-};
-
-ReceiveTaskExecution.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
-  const content = message.content;
-
-  const {id: signalId, executionId: signalExecutionId} = content.message || {};
-  const {message: referenceMessage, description} = this[kReferenceInfo];
-
-  if (!referenceMessage.id && signalId || signalExecutionId) {
-    if (this.loopCharacteristics && signalExecutionId !== this.executionId) return;
-    if (signalId !== this.id && signalExecutionId !== this.executionId) return;
-    this._debug('caught direct message');
-  } else if (referenceMessage.id !== signalId) return;
-  else {
-    this._debug(`caught ${description}`);
-  }
-
-  const {type: messageType, correlationId} = message.properties;
-  const broker = this.broker;
-  const executeContent = this[kExecuteMessage].content;
-
-  broker.publish('event', 'activity.consumed', cloneContent(executeContent, {message: {...message.content.message}}), {correlationId, type: messageType});
-  broker.publish('event', 'activity.catch', cloneContent(executeContent, {message: message.content.message}), {type: 'catch', correlationId});
-
-  this._complete(message.content.message, {correlationId});
-};
-
-ReceiveTaskExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
-  const {type: messageType, correlationId} = message.properties;
-  switch (messageType) {
-    case 'message':
-    case 'signal': {
-      return this._complete(message.content.message, {correlationId});
-    }
-    case 'discard': {
-      this[kCompleted] = true;
-      this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
-    }
-    case 'stop': {
-      return this._stop();
-    }
-  }
-};
-
-ReceiveTaskExecution.prototype._complete = function complete(output, options) {
-  this[kCompleted] = true;
-  this._stop();
-  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, {output}), options);
-};
-
-ReceiveTaskExecution.prototype._stop = function stop() {
-  const broker = this.broker, executionId = this.executionId;
-  broker.cancel(`_onmessage-${executionId}`);
-  broker.cancel(`_api-${executionId}`);
-};
-
-ReceiveTaskExecution.prototype._setupMessageHandling = function setupMessageHandling(executionId) {
-  const broker = this.broker;
-  broker.subscribeTmp('api', '#.signal.*', this._onDelegateMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_api-delegated-${executionId}`,
-  }, {
-    noAck: true,
-  });
-  broker.subscribeTmp('api', `activity.stop.${executionId}`, this._onStopApiMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_api-stop-${executionId}`,
-    priority: 400,
-  });
-  broker.subscribeTmp('execution', 'execute.#', this._onExecutionComplete.bind(this), {
-    noAck: true,
-    consumerTag: `_execution-complete-${executionId}`,
-  }, {
-    noAck: true,
-  });
-};
-
-ReceiveTaskExecution.prototype._onDelegateMessage = function onDelegateMessage(_, message) {
-  if (!message.properties.delegate) return;
-  this.broker.sendToQueue('message', message.content, message.properties);
-};
-
-ReceiveTaskExecution.prototype._onStopApiMessage = function onStopApiMessage() {
-  this._stopMessageHandling(true);
-};
-
-ReceiveTaskExecution.prototype._onExecutionComplete = function onExecutionComplete(routingKey, {content}) {
-  if (!content.isRootScope) return;
-  switch (routingKey) {
-    case 'execute.completed':
-    case 'execute.error':
-    case 'execute.discard':
-      this._stopMessageHandling();
-      break;
-  }
-};
-
-ReceiveTaskExecution.prototype._stopMessageHandling = function stop(keepMessageQ) {
-  const broker = this.broker, executionId = this.executionId;
-  broker.cancel(`_api-delegated-${executionId}`);
-  broker.cancel(`_api-stop-${executionId}`);
-  broker.cancel(`_execution-complete-${executionId}`);
-  if (!keepMessageQ) broker.purgeQueue('message');
-};
-
-ReceiveTaskExecution.prototype._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this.referenceElement;
-  if (!referenceElement) {
-    return {
-      message: {...this.reference},
-      description: 'anonymous message',
-    };
-  }
-
-  const result = {
-    message: referenceElement.resolve(message),
-  };
-
-  result.description = `${result.message.name} <${result.message.id}>`;
-
-  return result;
-};
-
-ReceiveTaskExecution.prototype._debug = function debug(msg) {
-  this.logger.debug(`<${this.executionId} (${this.id})> ${msg}`);
-};
+import Activity from '../activity/Activity.js';
+import {cloneContent} from '../messageHelper.js';
+
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kReferenceElement = Symbol.for('referenceElement');
+const kReferenceInfo = Symbol.for('referenceInfo');
+
+export default function ReceiveTask(activityDef, context) {
+  const task = new Activity(ReceiveTaskBehaviour, activityDef, context);
+
+  task.broker.assertQueue('message', {autoDelete: false, durable: true});
+  task.broker.bindQueue('message', 'api', '*.message.#', {durable: true});
+
+  return task;
+}
+
+export function ReceiveTaskBehaviour(activity) {
+  const {id, type, behaviour} = activity;
+
+  this.id = id;
+  this.type = type;
+
+  const reference = this.reference = {
+    name: 'anonymous',
+    ...behaviour.messageRef,
+    referenceType: 'message',
+  };
+
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.broker = activity.broker;
+
+  this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
+}
+
+ReceiveTaskBehaviour.prototype.execute = function execute(executeMessage) {
+  return new ReceiveTaskExecution(this).execute(executeMessage);
+};
+
+function ReceiveTaskExecution(parent) {
+  const {activity, broker, loopCharacteristics, reference} = parent;
+
+  this.id = activity.id;
+  this.logger = activity.logger;
+  this.reference = reference;
+  this.broker = broker;
+  this.loopCharacteristics = loopCharacteristics;
+  this.referenceElement = parent[kReferenceElement];
+
+  this[kCompleted] = false;
+}
+
+ReceiveTaskExecution.prototype.execute = function execute(executeMessage) {
+  this[kExecuteMessage] = executeMessage;
+
+  const executeContent = executeMessage.content;
+  const {executionId, isRootScope} = executeContent;
+  this.executionId = executionId;
+
+  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
+
+  if (isRootScope) {
+    this._setupMessageHandling(executionId);
+  }
+
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && executeMessage.content.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
+  }
+
+  const broker = this.broker;
+  broker.consume('message', this._onCatchMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_onmessage-${executionId}`,
+  });
+
+  if (this[kCompleted]) return;
+
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+    priority: 400,
+  });
+
+  this._debug(`expect ${info.description}`);
+
+  broker.publish('event', 'activity.wait', cloneContent(executeContent, {message: {...info.message}}));
+};
+
+ReceiveTaskExecution.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
+  const content = message.content;
+
+  const {id: signalId, executionId: signalExecutionId} = content.message || {};
+  const {message: referenceMessage, description} = this[kReferenceInfo];
+
+  if (!referenceMessage.id && signalId || signalExecutionId) {
+    if (this.loopCharacteristics && signalExecutionId !== this.executionId) return;
+    if (signalId !== this.id && signalExecutionId !== this.executionId) return;
+    this._debug('caught direct message');
+  } else if (referenceMessage.id !== signalId) return;
+  else {
+    this._debug(`caught ${description}`);
+  }
+
+  const {type: messageType, correlationId} = message.properties;
+  const broker = this.broker;
+  const executeContent = this[kExecuteMessage].content;
+
+  broker.publish('event', 'activity.consumed', cloneContent(executeContent, {message: {...message.content.message}}), {correlationId, type: messageType});
+  broker.publish('event', 'activity.catch', cloneContent(executeContent, {message: message.content.message}), {type: 'catch', correlationId});
+
+  this._complete(message.content.message, {correlationId});
+};
+
+ReceiveTaskExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
+  const {type: messageType, correlationId} = message.properties;
+  switch (messageType) {
+    case 'message':
+    case 'signal': {
+      return this._complete(message.content.message, {correlationId});
+    }
+    case 'discard': {
+      this[kCompleted] = true;
+      this._stop();
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
+    }
+    case 'stop': {
+      return this._stop();
+    }
+  }
+};
+
+ReceiveTaskExecution.prototype._complete = function complete(output, options) {
+  this[kCompleted] = true;
+  this._stop();
+  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, {output}), options);
+};
+
+ReceiveTaskExecution.prototype._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_onmessage-${executionId}`);
+  broker.cancel(`_api-${executionId}`);
+};
+
+ReceiveTaskExecution.prototype._setupMessageHandling = function setupMessageHandling(executionId) {
+  const broker = this.broker;
+  broker.subscribeTmp('api', '#.signal.*', this._onDelegateMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`,
+  }, {
+    noAck: true,
+  });
+  broker.subscribeTmp('api', `activity.stop.${executionId}`, this._onStopApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-stop-${executionId}`,
+    priority: 400,
+  });
+  broker.subscribeTmp('execution', 'execute.#', this._onExecutionComplete.bind(this), {
+    noAck: true,
+    consumerTag: `_execution-complete-${executionId}`,
+  }, {
+    noAck: true,
+  });
+};
+
+ReceiveTaskExecution.prototype._onDelegateMessage = function onDelegateMessage(_, message) {
+  if (!message.properties.delegate) return;
+  this.broker.sendToQueue('message', message.content, message.properties);
+};
+
+ReceiveTaskExecution.prototype._onStopApiMessage = function onStopApiMessage() {
+  this._stopMessageHandling(true);
+};
+
+ReceiveTaskExecution.prototype._onExecutionComplete = function onExecutionComplete(routingKey, {content}) {
+  if (!content.isRootScope) return;
+  switch (routingKey) {
+    case 'execute.completed':
+    case 'execute.error':
+    case 'execute.discard':
+      this._stopMessageHandling();
+      break;
+  }
+};
+
+ReceiveTaskExecution.prototype._stopMessageHandling = function stop(keepMessageQ) {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-delegated-${executionId}`);
+  broker.cancel(`_api-stop-${executionId}`);
+  broker.cancel(`_execution-complete-${executionId}`);
+  if (!keepMessageQ) broker.purgeQueue('message');
+};
+
+ReceiveTaskExecution.prototype._getReferenceInfo = function getReferenceInfo(message) {
+  const referenceElement = this.referenceElement;
+  if (!referenceElement) {
+    return {
+      message: {...this.reference},
+      description: 'anonymous message',
+    };
+  }
+
+  const result = {
+    message: referenceElement.resolve(message),
+  };
+
+  result.description = `${result.message.name} <${result.message.id}>`;
+
+  return result;
+};
+
+ReceiveTaskExecution.prototype._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.id})> ${msg}`);
+};

package/types/index.d.ts

@@ -2,7 +2,7 @@ declare module 'bpmn-elements' {
   import { Broker } from 'smqp';
   import { BrokerState } from 'smqp/types/Broker';
   import { Consumer } from 'smqp/types/Queue';
-  import { MessageMessage } from 'smqp/types/Message';
+  import { MessageMessage, MessageFields, MessageProperties } from 'smqp/types/Message';
   import { SerializableContext, SerializableElement } from 'moddle-context-serializer';
 
   interface ElementBroker<T> extends Broker {
@@ -25,16 +25,16 @@ declare module 'bpmn-elements' {
     [x: string]: any,
   }
 
-  type elementContent = {
-    id?: string,
-    type?: string,
-    executionId?: string,
-    parent?: ElementParent,
-    [x: string]: any,
+  interface ElementMessageContent {
+    id?: string;
+    type?: string;
+    executionId?: string;
+    parent?: ElementParent;
+    [x: string]: any;
   }
 
   interface ElementBrokerMessage extends MessageMessage {
-    content: elementContent,
+    content: ElementMessageContent,
   }
 
   interface EventDefinition {
@@ -211,8 +211,31 @@ declare module 'bpmn-elements' {
     createMessage(content?: Record<string, any>): any;
   }
 
+  interface ExecutionScope {
+    /** Calling element id */
+    id: string;
+    /** Calling element type */
+    type: string;
+    /** Execution message fields */
+    fields: MessageFields;
+    /** Execution message content */
+    content: ElementMessageContent;
+    /** Execution message properties */
+    properties: MessageProperties;
+    environment: Environment;
+    /** Calling element logger instance */
+    logger?: ILogger;
+    /**
+     * Resolve expression with the current scope
+     * @param expression expression string
+     * @returns Whatever the expression returns
+     */
+    resolveExpression: (expression: string) => any;
+    ActivityError: ActivityError;
+  }
+
   interface Script {
-    execute(executionContext: any, callback: CallableFunction): void;
+    execute(executionContext: ExecutionScope, callback: CallableFunction): void;
   }
 
   abstract class MessageElement {
@@ -458,6 +481,13 @@ declare module 'bpmn-elements' {
     shake(message: any): number;
     getCondition(): any;
     createMessage(override?: any): object;
+    /**
+     * Evaluate flow
+     * Executes condition if any, default flow is
+     * @param fromMessage Activity message
+     * @param {evaluateCallback} callback Callback with evaluation result, if truthy flow should be taken
+     */
+    evaluate(fromMessage: ElementBrokerMessage, callback: (err: Error, result: any) => void): void;
   }
 
   interface MessageFlowReference {
@@ -601,12 +631,21 @@ declare module 'bpmn-elements' {
   class Signal extends MessageElement {}
   class Escalation extends MessageElement {}
 
-  interface ActivityError extends Error {
+  class ActivityError extends Error {
     type: string;
     description: string;
     /** Activity that threw error */
     source?: ElementBrokerMessage;
     /** Original error */
     inner?: Error;
+    code?: string;
+    constructor(description: string, sourceMessage: MessageMessage, inner?: Error);
   }
 }
+
+/**
+ * Evaluate flow callback
+ * @callback evaluateCallback
+ * @param {Error} err Evaluation error
+ * @param {boolean|object} evaluationResult If thruthy flow should be taken
+ */