bpmn-elements 17.2.2 → 18.0.0

package/types/types.d.ts

@@ -1,765 +0,0 @@
-import { Broker } from 'smqp';
-import { BrokerState } from 'smqp/types/Broker';
-import { Consumer } from 'smqp/types/Queue';
-import { MessageMessage, MessageFields, MessageProperties } from 'smqp/types/Message';
-import { SerializableContext, SerializableElement } from 'moddle-context-serializer';
-
-declare interface ElementBroker<T> extends Broker {
-  get owner(): T;
-}
-
-declare type signalMessage = {
-  /**
-   * Optional signal id
-   * - Activity id
-   * - Signal-, Message-, Escalation id, etc
-   */
-  id?: string;
-  /**
-   * Optional execution id
-   * e.g. excutionId of a parallel multi instance user task
-   */
-  executionId?: string;
-  /** Any other input that will be added to completed activity output */
-  [x: string]: any;
-};
-
-declare interface ElementMessageContent {
-  id?: string;
-  type?: string;
-  executionId?: string;
-  parent?: ElementParent;
-  [x: string]: any;
-}
-
-declare interface ElementBrokerMessage extends MessageMessage {
-  content: ElementMessageContent;
-}
-
-declare class EventDefinition {
-  constructor(activity: Activity, eventDefinitionElement: SerializableElement, context?: ContextInstance, index?: number);
-  get id(): string;
-  get type(): string;
-  get executionId(): string;
-  get isThrowing(): boolean;
-  get activity(): Activity;
-  get broker(): Broker;
-  get logger(): ILogger;
-  get reference(): {
-    id?: string;
-    name: string;
-    referenceType: string;
-  };
-  [x: string]: any;
-  execute(executeMessage: ElementBrokerMessage): void;
-}
-
-declare const enum TimerType {
-  TimeCycle = 'timeCycle',
-  TimeDuration = 'timeDuration',
-  TimeDate = 'timeDate',
-}
-
-type parsedTimer = {
-  /** Expires at date time */
-  expireAt?: Date;
-  /** Repeat number of times */
-  repeat?: number;
-  /** Delay in milliseconds */
-  delay?: number;
-};
-
-declare class TimerEventDefinition extends EventDefinition {
-  /**
-   * Parse timer type
-   * @param timerType type of timer
-   * @param timerValue resolved expression timer string
-   */
-  parse(timerType: TimerType, timerValue: string): parsedTimer;
-}
-
-declare interface ICondition {
-  /** Condition type */
-  get type(): string;
-  [x: string]: any;
-  execute(message: ElementBrokerMessage, callback: CallableFunction): void;
-}
-
-declare class ConditionalEventDefinition extends EventDefinition {
-  /**
-   * Evaluate condition
-   * @param message
-   * @param callback
-   */
-  evaluate(message: ElementBrokerMessage, callback: CallableFunction): void;
-  /**
-   * Handle evaluate result or error
-   * @param err Condition evaluation error
-   * @param result Result from evaluated condition, completes execution if truthy
-   */
-  evaluateCallback(err: Error | null, result?: any): void;
-  /**
-   * Get condition from behaviour
-   * @param index Event definition sequence number, used to name registered script
-   */
-  getCondition(index: number): ICondition | null;
-}
-
-declare abstract class ElementBase {
-  get id(): string;
-  get type(): string;
-  get name(): string;
-  get parent(): ElementParent;
-  get behaviour(): SerializableElement;
-  get broker(): Broker;
-  get environment(): Environment;
-  get context(): ContextInstance;
-  get logger(): ILogger;
-}
-
-declare abstract class Element<T> extends ElementBase {
-  get broker(): ElementBroker<T>;
-  stop(): void;
-  resume(): void;
-  getApi(message?: ElementBrokerMessage): Api<T>;
-  on(eventName: string, callback: CallableFunction, options?: any): Consumer;
-  once(eventName: string, callback: CallableFunction, options?: any): Consumer;
-  waitFor(eventName: string, options?: any): Promise<Api<T>>;
-}
-
-declare interface ElementParent {
-  get id(): string;
-  get type(): string;
-  get executionId(): string;
-  get path(): ElementParent[];
-}
-
-declare type Extension = (activity: ElementBase, context: ContextInstance) => IExtension;
-declare interface IExtension {
-  activate(message: ElementBrokerMessage): void;
-  deactivate(message: ElementBrokerMessage): void;
-}
-
-declare interface IExpressions {
-  resolveExpression(templatedString: string, context?: any, expressionFnContext?: any): any;
-}
-
-declare interface EnvironmentSettings {
-  /** true returns dummy service function for service task if not found */
-  enableDummyService?: boolean;
-  /** true forces activity runs to go forward in steps, defaults to false */
-  step?: boolean;
-  /** strict mode, see documentation, defaults to false */
-  strict?: boolean;
-  /** positive integer to control parallel loop batch size, defaults to 50 */
-  batchSize?: number;
-  /**
-   * disable tracking state between recover and resume
-   * true will only return state for elements that are actually running
-   * Defaults to falsy
-   */
-  disableTrackState?: boolean;
-  [x: string]: any;
-}
-
-declare interface EnvironmentOptions {
-  settings?: EnvironmentSettings;
-  variables?: Record<string, any>;
-  services?: Record<string, CallableFunction>;
-  Logger?: LoggerFactory;
-  timers?: ITimers;
-  scripts?: IScripts;
-  extensions?: Record<string, Extension>;
-  /**
-   * optional override expressions handler
-   */
-  expressions?: IExpressions;
-}
-
-declare type startActivityFilterOptions = {
-  /** Event definition id, i.e. Message, Signal, Error, etc */
-  referenceId?: string;
-  /** Event definition type, i.e. message, signal, error, etc */
-  referenceType?: string;
-};
-
-type filterPostponed = (elementApi: Api<ElementBase>) => boolean;
-
-declare const enum DefinitionRunStatus {
-  Entered = 'entered',
-  Start = 'start',
-  Executing = 'executing',
-  End = 'end',
-  Discarded = 'discarded',
-}
-
-declare const enum ProcessRunStatus {
-  Entered = 'entered',
-  Start = 'start',
-  Executing = 'executing',
-  Errored = 'errored',
-  End = 'end',
-  Discarded = 'discarded',
-}
-
-/**
- * Activity status
- * Can be used to decide when to save states, Timer and Wait is recommended.
- */
-declare const enum ActivityStatus {
-  /** Idle, not running anything */
-  Idle = 'idle',
-  /**
-   * At least one activity is executing,
-   * e.g. a service task making a asynchronous request
-   */
-  Executing = 'executing',
-  /**
-   * At least one activity is waiting for a timer to complete,
-   * usually only TimerEventDefinition's
-   */
-  Timer = 'timer',
-  /**
-   * At least one activity is waiting for a signal of some sort,
-   * e.g. user tasks, intermediate catch events, etc
-   */
-  Wait = 'wait',
-}
-
-/**
- * Activity run status
- */
-declare const enum ActivityRunStatus {
-  /** Run entered, triggered by taken inbound flow */
-  Entered = 'entered',
-  /** Run started */
-  Started = 'started',
-  /** Executing activity behaviour */
-  Executing = 'executing',
-  /** Activity behaviour execution completed successfully */
-  Executed = 'executed',
-  /** Run end, take outbound flows */
-  End = 'end',
-  /** Entering discard run, triggered by discarded inbound flow */
-  Discard = 'discard',
-  /** Run was discarded, discard outbound flows */
-  Discarded = 'discarded',
-  /** Activity behaviour execution failed, discard run */
-  Error = 'error',
-  /** Formatting next run message */
-  Formatting = 'formatting',
-}
-
-declare interface DefinitionExecution {
-  get id(): string;
-  get type(): string;
-  get broker(): Broker;
-  get environment(): Environment;
-  get context(): ContextInstance;
-  get executionId(): string;
-  get stopped(): boolean;
-  get completed(): boolean;
-  get status(): string;
-  get processes(): Process[];
-  get postponedCount(): number;
-  get isRunning(): boolean;
-  get activityStatus(): ActivityStatus;
-  execute(executeMessage: ElementBrokerMessage): void;
-  getProcesses(): Process[];
-  getProcessById(processId: string): Process;
-  getProcessesById(processId: string): Process[];
-  getProcessByExecutionId(processExecutionId: string): Process;
-  getRunningProcesses(): Process[];
-  getExecutableProcesses(): Process[];
-  getPostponed(filterFn?: filterPostponed): Api<ElementBase>[];
-}
-
-declare interface ActivityExecution {
-  get completed(): boolean;
-  get executionId(): string;
-  get source(): IActivityBehaviour;
-  execute(executeMessage: ElementBrokerMessage): void;
-}
-
-declare interface IActivityBehaviour {
-  id: string;
-  type: string;
-  activity: Activity;
-  environment: Environment;
-  new (activity: Activity, context: ContextInstance): IActivityBehaviour;
-  execute(executeMessage: ElementBrokerMessage): void;
-}
-
-declare function ActivityBehaviour(activityDef: SerializableElement, context: ContextInstance): Activity;
-
-declare interface Api<T> extends ElementBrokerMessage {
-  get id(): string;
-  get type(): string;
-  get name(): string;
-  get executionId(): string;
-  get environment(): Environment;
-  get broker(): ElementBroker<T>;
-  get owner(): T;
-  cancel(message?: signalMessage, options?: any): void;
-  discard(): void;
-  fail(error: Error): void;
-  signal(message?: signalMessage, options?: any): void;
-  stop(): void;
-  resolveExpression(expression: string): any;
-  sendApiMessage(action: string, content?: signalMessage, options?: any): void;
-  getPostponed(...args: any[]): any[];
-  createMessage(content?: Record<string, any>): any;
-  getExecuting(): Api<T>[];
-}
-
-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;
-}
-
-declare interface Script {
-  execute(executionContext: ExecutionScope, callback: CallableFunction): void;
-}
-
-declare abstract class MessageElement {
-  get id(): string;
-  get type(): string;
-  get name(): string;
-  get parent(): ElementParent;
-  resolve(executionMessage: ElementBrokerMessage): {
-    parent: ElementParent;
-    name: string;
-    id: string;
-    type: string;
-    messageType: string;
-  };
-}
-
-declare class Environment {
-  constructor(options?: EnvironmentOptions);
-  options: Record<string, any>;
-  expressions: IExpressions;
-  extensions: Record<string, IExtension>;
-  scripts: IScripts;
-  timers: ITimers;
-  Logger: LoggerFactory;
-  get settings(): EnvironmentSettings;
-  get variables(): Record<string, any>;
-  get output(): Record<string, any>;
-  set services(arg: any);
-  get services(): any;
-  getState(): EnvironmentState;
-  recover(state?: EnvironmentState): Environment;
-  clone(overrideOptions?: EnvironmentOptions): Environment;
-  assignVariables(newVars: Record<string, any>): void;
-  assignSettings(newSettings: Record<string, any>): void;
-  registerScript(activity: any): Script;
-  getScript(language: string, identifier: { id: string; [x: string]: any }): Script;
-  getServiceByName(serviceName: string): CallableFunction;
-  resolveExpression(expression: string, message?: ElementBrokerMessage, expressionFnContext?: any): any;
-  addService(name: string, fn: CallableFunction): void;
-}
-
-declare function Context(definitionContext: SerializableContext, environment?: Environment): ContextInstance;
-declare class ContextInstance {
-  constructor(definitionContext: SerializableContext, environment?: Environment);
-  get id(): string;
-  get name(): string;
-  get type(): string;
-  /** Unique context instance id */
-  get sid(): string;
-  get definitionContext(): SerializableContext;
-  get environment(): Environment;
-  /** Context owner, Process or SubProcess activity */
-  get owner(): Process | Activity | undefined;
-  getActivityById<T>(activityId: string): T;
-  getSequenceFlowById(sequenceFlowId: string): SequenceFlow;
-  getInboundSequenceFlows(activityId: string): SequenceFlow[];
-  getOutboundSequenceFlows(activityId: string): SequenceFlow[];
-  getInboundAssociations(activityId: string): Association[];
-  getOutboundAssociations(activityId: string): Association[];
-  getActivities(scopeId?: string): ElementBase[];
-  getSequenceFlows(scopeId?: string): SequenceFlow[];
-  getAssociations(scopeId?: string): Association[];
-  clone(newEnvironment?: Environment): ContextInstance;
-  getProcessById(processId: string): Process;
-  getNewProcessById(processId: string): Process;
-  getProcesses(): Process[];
-  getExecutableProcesses(): Process[];
-  getMessageFlows(sourceId: string): MessageFlow[];
-  getDataObjectById(referenceId: string): any;
-  getDataStoreById(referenceId: string): any;
-  getStartActivities(filterOptions?: startActivityFilterOptions, scopeId?: string): Activity[];
-  loadExtensions(activity: ElementBase): IExtension;
-}
-
-declare interface ElementState {
-  id: string;
-  type: string;
-  broker?: BrokerState;
-  [x: string]: any;
-}
-
-declare interface EnvironmentState {
-  settings: EnvironmentSettings;
-  variables: Record<string, any>;
-  output: Record<string, any>;
-}
-
-declare type completedCounters = { completed: number; discarded: number };
-
-declare interface ActivityExecutionState {
-  completed: boolean;
-  [x: string]: any;
-}
-
-declare interface ActivityState extends ElementState {
-  status?: string;
-  executionId: string;
-  stopped: boolean;
-  counters: { taken: number; discarded: number };
-  execution?: ActivityExecutionState;
-}
-
-declare interface SequenceFlowState extends ElementState {
-  counters: { take: number; discard: number; looped: number };
-}
-
-declare interface MessageFlowState extends ElementState {
-  counters: { messages: number };
-}
-
-declare interface AssociationState extends ElementState {
-  counters: { take: number; discard: number };
-}
-
-declare interface ProcessExecutionState {
-  executionId: string;
-  stopped: boolean;
-  completed: boolean;
-  status: string;
-  children: ActivityState[];
-  flows?: SequenceFlowState[];
-  messageFlows?: MessageFlowState[];
-  associations?: AssociationState[];
-}
-
-declare interface ProcessState extends ElementState {
-  status: string;
-  stopped: boolean;
-  executionId?: string;
-  counters: completedCounters;
-  environment: EnvironmentState;
-  execution?: ProcessExecutionState;
-}
-
-declare interface DefinitionExecutionState {
-  executionId: string;
-  stopped: boolean;
-  completed: boolean;
-  status: string;
-  processes: ProcessState[];
-}
-
-declare interface DefinitionState extends ElementState {
-  status: string;
-  stopped: boolean;
-  executionId?: string;
-  counters: completedCounters;
-  environment: EnvironmentState;
-  execution?: DefinitionExecutionState;
-}
-
-declare type runCallback = (err: Error, definitionApi: Api<Definition>) => void;
-declare class Definition extends Element<Definition> {
-  constructor(context: ContextInstance, options?: EnvironmentOptions);
-  get counters(): completedCounters;
-  get execution(): DefinitionExecution;
-  get executionId(): string;
-  get isRunning(): boolean;
-  get status(): DefinitionRunStatus | undefined;
-  get stopped(): boolean;
-  get activityStatus(): ActivityStatus;
-  run(): Definition;
-  run(runContent: Record<string, any>): Definition;
-  run(runContent: Record<string, any>, callback: runCallback): Definition;
-  run(callback: runCallback): Definition;
-  getState(): DefinitionState;
-  recover(state?: DefinitionState): Definition;
-  resume(): void;
-  resume(callback: (err: Error, definitionApi: Api<Definition>) => void): void;
-  shake(startId?: string): object;
-  getProcesses(): Process[];
-  /** get processes marked with isExecutable=true */
-  getExecutableProcesses(): Process[];
-  getRunningProcesses(): Process[];
-  getProcessById(processId: string): Process;
-  getActivityById(childId: string): Activity;
-  getElementById<T>(elementId: string): Element<T>;
-  getPostponed(filterFn?: filterPostponed): Api<ElementBase>[];
-  /** Send delegated signal message */
-  signal(message: any): void;
-  cancelActivity(message: any): void;
-  sendMessage(message: any): void;
-}
-
-declare class Process extends Element<Process> {
-  constructor(processDef: SerializableElement, context: ContextInstance);
-  get isExecutable(): boolean;
-  get counters(): completedCounters;
-  get lanes(): Lane[] | undefined;
-  get extensions(): IExtension;
-  get stopped(): boolean;
-  get isRunning(): boolean;
-  get executionId(): string;
-  get execution(): ProcessExecution;
-  get status(): ProcessRunStatus | undefined;
-  get activityStatus(): ActivityStatus;
-  init(useAsExecutionId?: string): void;
-  run(runContent?: Record<string, any>): void;
-  getState(): ProcessState;
-  recover(state?: ProcessState): Process;
-  shake(startId?: string): void;
-  signal(message: any): any;
-  cancelActivity(message: any): any;
-  sendMessage(message: any): void;
-  getActivityById<T>(childId: string): T;
-  getActivities(): Activity[];
-  getStartActivities(filterOptions?: startActivityFilterOptions): Activity[];
-  getSequenceFlows(): SequenceFlow[];
-  getLaneById(laneId: string): Lane | undefined;
-  getPostponed(filterFn: filterPostponed): Api<ElementBase>[];
-}
-
-declare interface ProcessExecution {
-  get isSubProcess(): boolean;
-  get broker(): Broker;
-  get environment(): Environment;
-  get context(): ContextInstance;
-  get executionId(): string;
-  get stopped(): boolean;
-  get completed(): boolean;
-  get status(): string;
-  get postponedCount(): number;
-  get isRunning(): boolean;
-  get activityStatus(): ActivityStatus;
-  execute(executeMessage: ElementBrokerMessage): void;
-  getPostponed(filterFn: filterPostponed): Api<ElementBase>[];
-  getActivities(): Activity[];
-  getActivityById<T>(activityId: string): T;
-  getSequenceFlows(): SequenceFlow[];
-  getApi(message?: ElementBrokerMessage): Api<ElementBase>;
-}
-
-declare class Lane extends ElementBase {
-  constructor(process: Process, laneDefinition: SerializableElement);
-  /** Process broker */
-  get broker(): Broker;
-  get process(): Process;
-}
-
-declare interface ISequenceFlowCondition {
-  /** Condition type, e.g. script or expression */
-  get type(): string;
-  /**
-   * Execute sequence flow condition
-   * @param message Source element execution message
-   * @param callback Callback with truthy result if flow should be taken
-   */
-  execute(message: ElementBrokerMessage, callback: (err: Error, result: any) => void): void;
-}
-
-declare class SequenceFlow extends Element<SequenceFlow> {
-  constructor(flowDef: SerializableElement, context: ContextInstance);
-  get sourceId(): string;
-  get targetId(): string;
-  get isDefault(): boolean;
-  get isSequenceFlow(): boolean;
-  get counters(): { take: number; discard: number; looped: number };
-  take(content?: any): boolean;
-  discard(content?: any): void;
-  shake(message: any): number;
-  getCondition(): ISequenceFlowCondition | null;
-  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;
-  getState(): SequenceFlowState | undefined;
-}
-
-declare interface MessageFlowReference {
-  /** activity id */
-  get id(): string;
-  get processId(): string;
-}
-
-declare class MessageFlow extends Element<MessageFlow> {
-  constructor(flowDef: SerializableElement, context: ContextInstance);
-  get source(): MessageFlowReference;
-  get target(): MessageFlowReference;
-  get counters(): { messages: number };
-  activate(): void;
-  deactivate(): void;
-  getState(): MessageFlowState | undefined;
-}
-
-declare class Association extends Element<Association> {
-  constructor(associationDef: SerializableElement, context: ContextInstance);
-  get sourceId(): string;
-  get targetId(): string;
-  get isAssociation(): boolean;
-  get counters(): { take: number; discard: number };
-  take(content?: any): boolean;
-  discard(content?: any): boolean;
-  getState(): AssociationState | undefined;
-}
-
-declare type LoggerFactory = (scope: string) => ILogger;
-
-declare interface ILogger {
-  debug(...args: any[]): void;
-  error(...args: any[]): void;
-  warn(...args: any[]): void;
-  [x: string]: any;
-}
-
-declare type wrappedSetTimeout = (handler: CallableFunction, delay: number, ...args: any[]) => Timer;
-declare type wrappedClearTimeout = (ref: any) => void;
-
-declare interface Timer {
-  /** The function to call when the timer elapses */
-  readonly callback: CallableFunction;
-  /** The number of milliseconds to wait before calling the callback */
-  readonly delay: number;
-  /** Optional arguments to pass when the callback is called */
-  readonly args?: any[];
-  /** Timer owner if any */
-  readonly owner?: any;
-  /** Timer Id */
-  readonly timerId: string;
-  /** Timeout, return from setTimeout */
-  readonly timerRef: any;
-  [x: string]: any;
-}
-
-declare interface RegisteredTimer {
-  owner?: any;
-  get setTimeout(): wrappedSetTimeout;
-  get clearTimeout(): wrappedClearTimeout;
-}
-
-declare interface ITimers {
-  get setTimeout(): wrappedSetTimeout;
-  get clearTimeout(): wrappedClearTimeout;
-  register(owner?: any): RegisteredTimer;
-  [x: string]: any;
-}
-
-declare interface TimersOptions {
-  /** Defaults to builtin setTimeout */
-  setTimeout?: typeof setTimeout;
-  /** Defaults to builtin clearTimeout */
-  clearTimeout?: typeof clearTimeout;
-  [x: string]: any;
-}
-
-declare class Timers implements ITimers {
-  options: TimersOptions;
-  constructor(options?: TimersOptions);
-  get executing(): Timer[];
-  get setTimeout(): wrappedSetTimeout;
-  get clearTimeout(): wrappedClearTimeout;
-  register(owner?: any): RegisteredTimer;
-}
-
-declare interface IScripts {
-  register(activity: any): Script | undefined;
-  getScript(language: string, identifier: { id: string; [x: string]: any }): Script;
-}
-
-declare class MessageFormatter {
-  id: string;
-  broker: Broker;
-  logger: ILogger;
-  format(message: MessageElement, callback: CallableFunction): void;
-}
-
-declare class Activity extends Element<Activity> {
-  constructor(behaviour: IActivityBehaviour, activityDef: SerializableElement, context: ContextInstance);
-  get Behaviour(): IActivityBehaviour;
-  get stopped(): boolean;
-  get status(): ActivityRunStatus | undefined;
-  get context(): ContextInstance;
-  get counters(): { taken: number; discarded: number };
-  get execution(): ActivityExecution;
-  get executionId(): string;
-  get extensions(): IExtension;
-  get isRunning(): boolean;
-  get outbound(): SequenceFlow[];
-  get inbound(): SequenceFlow[];
-  get isEnd(): boolean;
-  get isStart(): boolean;
-  get isSubProcess(): boolean;
-  get isMultiInstance(): boolean;
-  get isThrowing(): boolean;
-  get isForCompensation(): boolean;
-  get triggeredByEvent(): boolean;
-  get attachedTo(): Activity;
-  get eventDefinitions(): EventDefinition[];
-  get formatter(): MessageFormatter;
-  /** Parent element process or sub process reference */
-  get parentElement(): Process | Activity;
-  activate(): void;
-  deactivate(): void;
-  init(initContent?: any): void;
-  run(runContent?: any): void;
-  discard(discardContent?: any): void;
-  next(): ElementBrokerMessage;
-  shake(): void;
-  evaluateOutbound(
-    fromMessage: ElementBrokerMessage,
-    discardRestAtTake: boolean,
-    callback: (err: Error, evaluationResult: any) => void
-  ): void;
-  getState(): ActivityState | undefined;
-}
-
-declare 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
- */