bpmn-engine 15.1.2 → 16.0.0

package/CHANGELOG.md

@@ -1,6 +1,16 @@
 Changelog
 =========
 
+# 16.0.0
+
+- Refactor type declarations using types from bpmn-elements, smqp, etc
+- add activity status property
+- Bump [`bpmn-elements@9.1.0`](https://github.com/paed01/bpmn-elements/blob/master/CHANGELOG.md)
+
+# 15.1.3
+
+- fix(types): add missing `settings` option
+
 # 15.1.2
 
 - Patch [`bpmn-elements@8.2.2`](https://github.com/paed01/bpmn-elements/blob/master/CHANGELOG.md)

package/index.js

@@ -107,6 +107,15 @@ Object.defineProperty(Engine.prototype, 'execution', {
   },
 });
 
+Object.defineProperty(Engine.prototype, 'activityStatus', {
+  enumerable: true,
+  get() {
+    const execution = this.execution;
+    if (execution) return execution.activityStatus;
+    return 'idle';
+  },
+});
+
 Engine.prototype.execute = async function execute(...args) {
   const [executeOptions, callback] = getOptionsAndCallback(...args);
   try {
@@ -306,6 +315,30 @@ Object.defineProperty(Execution.prototype, 'environment', {
   },
 });
 
+Object.defineProperty(Execution.prototype, 'activityStatus', {
+  get() {
+    let status = 'idle';
+    const running = this[kExecuting];
+    if (!running.length) return status;
+
+    for (const def of running) {
+      const bpStatus = def.activityStatus;
+      switch (def.activityStatus) {
+        case 'executing':
+          return bpStatus;
+        case 'timer':
+          status = bpStatus;
+          break;
+        case 'wait':
+          if (status === 'idle') status = bpStatus;
+          break;
+      }
+    }
+
+    return status;
+  },
+});
+
 Execution.prototype._execute = function execute(executeOptions, callback) {
   this._setup(executeOptions);
   this[kStopped] = false;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmn-engine",
   "description": "BPMN 2.0 execution engine. Open source javascript workflow engine.",
-  "version": "15.1.2",
+  "version": "16.0.0",
   "main": "index.js",
   "types": "types/bpmn-engine.d.ts",
   "repository": {
@@ -22,10 +22,11 @@
   ],
   "scripts": {
     "test": "mocha -R dot",
-    "posttest": "eslint . --cache && npm run toc",
+    "posttest": "npm run lint && npm run toc",
+    "lint": "eslint . --cache",
     "wintest": "mocha",
-    "cov:html": "nyc mocha -R dot && nyc report --reporter=html",
-    "test:lcov": "nyc mocha -R dot && nyc report --reporter lcov && npm run posttest",
+    "cov:html": "c8 -r html -r text mocha -R dot",
+    "test:lcov": "c8 -r lcov mocha && npm run lint",
     "toc": "node scripts/generate-api-toc ./docs/API.md,./docs/Examples.md",
     "test-md": "node scripts/test-markdown.js ./docs/API.md && node scripts/test-markdown.js ./docs/Examples.md"
   },
@@ -44,29 +45,24 @@
       "url": "https://github.com/paed01/bpmn-engine/master/LICENSE"
     }
   ],
-  "nyc": {
-    "exclude": [
-      "test"
-    ]
-  },
   "devDependencies": {
     "bent": "^7.3.12",
-    "camunda-bpmn-moddle": "^6.1.2",
+    "c8": "^7.13.0",
+    "camunda-bpmn-moddle": "^7.0.1",
     "chai": "^4.3.7",
-    "chronokinesis": "^3.0.0",
-    "eslint": "^8.27.0",
+    "chronokinesis": "^4.0.1",
+    "eslint": "^8.37.0",
     "markdown-toc": "^1.2.0",
-    "mocha": "^10.1.0",
+    "mocha": "^10.2.0",
     "mocha-cakes-2": "^3.3.0",
-    "nock": "^13.2.9",
-    "nyc": "^15.1.0"
+    "nock": "^13.3.0"
   },
   "dependencies": {
     "@types/bpmn-moddle": "^5.1.6",
-    "bpmn-elements": "^8.2.2",
-    "bpmn-moddle": "^7.1.3",
+    "bpmn-elements": "^9.1.0",
+    "bpmn-moddle": "^8.0.1",
     "debug": "^4.3.4",
-    "moddle-context-serializer": "^2.0.0",
-    "smqp": "^6.1.0"
+    "moddle-context-serializer": "^3.2.2",
+    "smqp": "^7.1.3"
   }
 }

package/types/bpmn-engine.d.ts

@@ -1,7 +1,10 @@
 // Author : Saeed Tabrizi
+// Refactored by : Pål Edman
 
-import {EventEmitter} from 'events';
-import {Definitions} from 'bpmn-moddle';
+import { EventEmitter } from 'events';
+import { Definitions as BpmnModdleDefinitions } from 'bpmn-moddle';
+import { extendFn, SerializableContext } from 'moddle-context-serializer';
+import { ActivityStatus, ElementBroker, EnvironmentOptions, Definition, DefinitionState, Environment, Api, ElementBase, ILogger, EnvironmentState } from 'bpmn-elements';
 
 declare module 'bpmn-engine' {
 
@@ -43,13 +46,8 @@ declare module 'bpmn-engine' {
         flow.looped: The sequence is looped
    */
   export type BpmnSequenceFlowEvent = 'flow.take' | 'flow.discard' | 'flow.looped';
-  export type BpmnEngineVariable = Record<string, any>;
-
-  export interface BpmnLogger {
-    debug(...args: any[]): void;
-    error(...args: any[]): void;
-    warn(...args: any[]): void;
-  }
+  // export type BpmnEngineVariable = Record<string, any>;
+  // export type BpmnEngineSetting = Record<string, any>;
 
   export interface BpmnMessage {
     id?: string,
@@ -57,152 +55,11 @@ declare module 'bpmn-engine' {
     [name: string]: any
   }
 
-  export interface BpmnEngineBrokerExchange {
-    name: string;
-    type: 'topic' | 'direct';
-    options: any;
-    bindingCount: number;
-    bindings: any[];
-    stopped: boolean;
-    bind(queue: string, pattern: string, bindOptions?: any): void;
-    close(): void;
-    emit(eventName: string, content?: any): void;
-    getBinding(queueName: string, pattern: string): any;
-    getState<S>(): S;
-    on(pattern: string, handler: () => void, consumeOptions?: any): void;
-    off(pattern: string, handler: () => void): void;
-    publish(routingKey: string, content?: any, properties?: any): void;
-    recover<S>(state: S, getQueue?: boolean): void;
-    stop(): void;
-    unbind(queue: string, pattern: string): void;
-    unbindQueueByName(queueName: string): void;
-  }
-
-  export interface BpmnEngineBrokerQueue {
-    name: string;
-    options: any;
-    messages: any[];
-    messageCount: number;
-    consumerCount: number;
-    stopped: boolean;
-    exclusive: boolean;
-    maxLength: number;
-    readonly capacity: number;
-    messageTtl: number;
-    ack(message: any): void;
-    ackAll(): void;
-    assertConsumer(onMessage: () => void, consumeOptions?: any, owner?: any): void;
-    cancel(consumerTag: string): void;
-    close(): void;
-    consume(onMessage: () => void, consumeOptions?: any, owner?: any): void;
-    delete(deleteOptions?: any): void;
-    dequeueMessage(message: any): void;
-    dismiss(onMessage: () => void): void;
-    get<T>(consumeOptions?: any): T;
-    getState<S>(): S;
-    nack(message: any, allUpTo?: boolean, requeue?: boolean): void;
-    nackAll(requeue: boolean): void;
-    off(eventName: string, handler: () => void): void;
-
-    on(eventName: string, handler: () => void): void;
-
-    peek(ignoreDelivered?: boolean): void;
-    purge(): void;
-
-    queueMessage(fields: any[], content?: any, properties?: any, onMessageQueued?: () => void): void;
-    recover<S>(state: S): void;
-    reject(message: any, requeue?: boolean): void;
-    stop(): void;
-    unbindConsumer(): void;
-  }
-
-  export interface BpmnEngineBrokerConsumer {
-    consumerTag: string;
-    noAck: any;
-    onMessage: () => void;
-    options: any;
-    priority: number;
-    queueName: string;
-    ackAll(): void;
-    nackAll(requeue: boolean): void;
-    cancel(): void;
-  }
-
-  export interface BpmnEngineBrokerMessage {
-    fields: {routingKey: string, redelivered: boolean, exchange: any, consumerTag: string}[];
-    content: any;
-    properties: {messageId: string, persistent: boolean, timestamp: Date, expiration: number};
-    ack(allUpTo?: boolean): void;
-    nack(allUpTo?: boolean, requeue?: boolean): void;
-    reject(requeue?: boolean): void;
-    getRoutingKeyPattern(pattern: string): (test: string) => boolean;
-  }
-
-  export interface BpmnEngineBroker<W> {
-    new(owner: W): BpmnEngineBroker<W>;
-    readonly owner: W;
-    assertExchange(exchangeName: string, type: string, options?: any): void;
-    deleteExchange(exchangeName: string, ifUnused?: boolean): void;
-    bindExchange(source: string, destination: string, pattern: string, ...args: any[]): void;
-
-    unbindExchange(source: string, destination: string, pattern?: string): void;
-    assertQueue(queueName: string, options?: any): void;
-    bindQueue(queueName: string, exchangeName: string, pattern: string, options?: any): void;
-    unbindQueue(queueName: string, exchangeName: string, pattern: string): void;
-
-    consume(queueName: string, onMessage: () => void, options?: any): void;
-    cancel(consumerTag: string): void;
-    createQueue<Q>(): Q;
-    deleteQueue(queueName: string, options?: {ifUnused: boolean, ifEmpty?: boolean}): void;
-
-    getExchange<T>(exchangeName: string): T;
-    getQueue<Q>(queueName: string): Q;
-    getConsumers<C>(): C[];
-    getConsumer<C>(consumerTag: string): C;
-    getState<S>(): S;
-    recover<S>(state?: S): void;
-    purgeQueue(queueName: string): void;
-    sendToQueue(queueName: string, content: any, options?: any): void;
-    stop(): void;
-    get(queueName: string, options?: any): void;
-
-    ack(message: any, allUpTo?: boolean): void;
-    ackAll(): void;
-    nack(message: any, allUpTo?: boolean, requeue?: boolean): void;
-    nackAll(requeue?: boolean): void;
-    reject(message: any, requeue?: boolean): void;
-
-    createShovel<S>(name: string, source: string, destination: string, options?: any): S;
-    getShovel<S>(name: string): S;
-    closeShovel(name: string): void;
-    prefetch(count: number): void;
-
-    reset(): void;
-    on(eventName: string, handler: () => void): void;
-    off(eventName: string, handler: () => void): void;
-    unsubscribe(queueName: string, onMessage: () => void): void;
-    cancel(eventName: string): void;
-    subscribe(exchangeName: string, pattern: string, queueName: string, onMessage: () => void, options?: any): void;
-    subscribeTmp(exchangeName: string, pattern: string, queueName: string, onMessage: () => void, options?: any): void;
-    subscribeOnce(exchangeName: string, pattern: string, queueName: string, onMessage: () => void, options?: any): void;
-    publish(exchangeName: string, routingKey: string, content?: any, options?: any): void;
-    close(): void;
-
-  }
-
-  export interface BpmnEngineExecuteOptions {
-    variables?: BpmnEngineVariable;
+  export interface BpmnEngineExecuteOptions extends EnvironmentOptions {
     listener?: EventEmitter;
-    services?: BpmnEngineService;
-
-    /**
-     * optional override expressions handler
-     */
-    expressions?: BpmnEngineExpressions;
   }
 
-  export interface BpmnEngineOptions {
-
+  export interface BpmnEngineOptions extends BpmnEngineExecuteOptions {
     /**
      * optional name of engine,
      */
@@ -212,55 +69,46 @@ declare module 'bpmn-engine' {
      */
     source?: string;
     /**
-     *  optional serialized context supplied by moddle-context-serializer
+     * optional serialized context supplied by moddle-context-serializer
      */
-    sourceContext?: any;
-    variables?: BpmnEngineVariable;
+    sourceContext?: SerializableContext;
     /**
-     * optional Logger factory, defaults to debug logger
+     * optional override of BPMN Elements behaviors, defaults to bpmn-elements
      */
-    Logger?: (scope: string) => BpmnLogger;
-
+    elements?: Record<string, any>;
     /**
-     * optional inline script handler, defaults to nodejs vm module handling, i.e. JavaScript
+     * Passed to moddle-context-serializer as extendFn
      */
-    scripts?: any;
-
-    listener?: EventEmitter;
-    // tslint:disable-next-line:ban-types
-    services?: BpmnEngineService;
-
-    elements?: any;
-
-    typeResolver?: <R>(...elements: any) => R;
+    typeResolver?: extendFn;
     /**
      * optional bpmn-moddle options to be passed to bpmn-moddle
      */
     moddleOptions?: any;
-    moddleContext?: Definitions;
+    moddleContext?: BpmnModdleDefinitions;
+  }
 
-    extensions?: BpmnEngineExtension;
+  const enum BpmnEngineRunningStatus {
     /**
-     * optional override expressions handler
+     * Engine is not executing
      */
-    expressions?: BpmnEngineExpressions;
-  }
-
-  export interface BpmnEngineExtension {
-    [name: string]: (activiy?: BpmnEngineActivity, environment?: BpmnEngineExecutionEnvironment) => void;
-  }
-
-  export interface BpmnEngineExpressions {
-    resolveExpression<R>(
-      expression: string,
-      message?: any,
-      expressionFnContext?: any,
-    ): R;
+    Idle = 'idle',
+    /**
+     * Engine is executing
+     */
+    Running = 'running',
+    /**
+     * Engine execution is stopped
+     */
+    Stopped = 'stopped',
+    /**
+     * Engine execution has errored
+     */
+    Error = 'error',
   }
 
-  export interface BpmnEngine {
-    new(options?: BpmnEngineOptions): BpmnEngine;
-
+  export function Engine(options?: BpmnEngineOptions): Engine;
+  export class Engine extends EventEmitter {
+    constructor(options?: BpmnEngineOptions);
     /**
      * engine name
      */
@@ -268,11 +116,11 @@ declare module 'bpmn-engine' {
     /**
      * engine broker
      */
-    broker: BpmnEngineBroker<BpmnEngine>;
+    broker: ElementBroker<Engine>;
     /**
      * engine state
      */
-    readonly state: any;
+    readonly state: BpmnEngineRunningStatus;
     /**
      * boolean stopped
      */
@@ -280,15 +128,16 @@ declare module 'bpmn-engine' {
     /**
      * current engine execution
      */
-    readonly  execution: BpmnEngineExecutionApi;
+    readonly  execution: Execution;
     /**
      * engine environment
      */
-    readonly environment: BpmnEngineExecutionEnvironment;
+    readonly environment: Environment;
     /**
      *  engine logger
      */
-    readonly logger: BpmnLogger;
+    readonly logger: ILogger;
+    get activityStatus(): ActivityStatus;
 
     /**
      * execute definition
@@ -296,18 +145,21 @@ declare module 'bpmn-engine' {
      * @param cb Callback called before the throw
      * @summary Execute options overrides the initial options passed to the engine before executing the definition.
      */
-    execute(options?:BpmnEngineExecuteOptions, cb?: (err) => void): Promise<BpmnEngineExecutionApi>;
+    execute(): Promise<Execution>;
+    execute(options: BpmnEngineExecuteOptions): Promise<Execution>;
+    execute(options: BpmnEngineExecuteOptions, cb: (err: Error) => void): Promise<Execution>;
+    execute(cb: (err: Error) => void): Promise<Execution>;
 
     /**
      * get definition by id
      * @param id id of definition
      */
-    getDefinitionById(id: string): Promise<any>;
+    getDefinitionById(id: string): Promise<Definition>;
 
     /**
      * get all definitions
      */
-    getDefinitions(): Promise<any[]>;
+    getDefinitions(): Promise<Definition[]>;
 
     /**
      * get execution serialized state
@@ -319,348 +171,46 @@ declare module 'bpmn-engine' {
      * @param state engine state
      * @param recoverOptions  optional object with options that will completely override the options passed to the engine at init
      */
-    recover(state: any, recoverOptions?: BpmnEngineOptions): BpmnEngine;
+    recover(state: any, recoverOptions?: BpmnEngineOptions): Engine;
 
     /**
      * Resume execution function with previously saved engine state.
      * @param options
      * @param callback
      */
-    resume(options?: BpmnEngineExecuteOptions, callback?: () => void): Promise<BpmnEngineExecutionApi>;
+    resume(options?: BpmnEngineExecuteOptions, callback?: () => void): Promise<Execution>;
 
     /**
      * Stop execution. The instance is terminated.
      */
     stop(): void;
 
-    waitFor<R>(eventName: string): Promise<R>;
+    waitFor<R>(eventName: BpmnEngineEvent): Promise<R>;
 
     /**
      * Add definition source by source context.
      * @param options
      */
     addSource(options?: {sourceContext: any}): void;
-
-  }
-
-  export function Engine(options?: BpmnEngineOptions): BpmnEngine;
-
-  export interface BpmnEngineExecution {
-    definitions: BpmnEngineExecutionDefinition[];
-    state: 'idle' | 'running';
-    environment: BpmnEngineExecutionEnvironment;
-
-    stopped: boolean;
-    execute(executeOptions?: any): BpmnEngineExecutionApi;
-    getState<R>(): R;
-
-    resume(resumeOptions?: any): void;
-
-    stop(): void;
-
-  }
-
-  export interface BpmnEngineExecutionContext {
-    id: string;
-    name: string;
-    type: string;
-    sid: any;
-    definitionContext: any;
-    environment: BpmnEngineExecutionEnvironment;
-
-    clone(
-      environment?: BpmnEngineExecutionEnvironment
-    ): BpmnEngineExecutionContext;
-    getActivities(scopeId?: string): BpmnEngineActivity[];
-    getActivityById(id: string): BpmnEngineActivity;
-    getExecutableProcesses(): any[];
-    getDataObjectById(id: string): any;
-
-    getMessageFlows(): any[];
-
-    getProcessById(id: string): any;
-
-    getProcesses(): any;
-
-    getSequenceFlowById(id: string): any;
-
-    getSequenceFlows(scopeId: string): any[];
-
-    getInboundSequenceFlows(activityId: string): any[];
-    getOutboundSequenceFlows(activityId: string): any[];
-
-    loadExtensions(activity: BpmnEngineActivity): void;
-  }
-
-  export interface BpmnProcess {
-    new(processDefinition: any, context: BpmnEngineExecutionContext): BpmnProcess;
-
-    readonly id: string;
-    readonly type: string;
-    readonly name: string;
-    readonly isExecutable: boolean;
-    readonly broker: BpmnEngineBroker<BpmnEngine>;
-
-    readonly context: BpmnEngineExecutionContext;
-    readonly counters: Record<string, number>;
-    readonly environment: BpmnEngineExecutionEnvironment;
-    readonly execution: BpmnEngineExecutionApi;
-    readonly executionId: string;
-    readonly isRunning: boolean;
-
-    readonly logger: BpmnLogger;
-    readonly parent: BpmnProcess;
-    readonly status: any;
-
-    readonly stopped: boolean;
-
-    getApi(message: any): BpmnEngineExecutionApi;
-    getActivities(): BpmnEngineActivity[];
-    getActivityById(id: string): BpmnEngineActivity;
-
-    getSequenceFlows(): any[];
-    getPostponed(): BpmnEngineActivity[];
-
-    getState<S>(): S;
-
-    recover<S>(state: S): void;
-    resume(): void;
-    run(): void;
-    stop(): void;
-    waitFor<R>(eventName: string): Promise<R>;
-  }
-
-  export interface BpmnEngineActivity extends EventEmitter {
-    readonly id: string;
-    readonly type: string;
-    readonly  name: string;
-
-    readonly attachedTo: any;
-
-    readonly  Behaviour: any;
-
-    readonly  behaviour: any;
-
-    readonly broker: BpmnEngineBroker<BpmnEngine>;
-
-    readonly counters: Record<string, number>;
-    readonly environment: BpmnEngineExecutionEnvironment;
-    readonly execution: BpmnEngineExecutionApi;
-    readonly executionId: string;
-    readonly extensions: BpmnEngineExtension;
-    readonly logger: BpmnLogger;
-    readonly inbound: any[];
-    readonly isRunning: boolean;
-    readonly isStart: boolean;
-    readonly isSubProcess: boolean;
-
-    readonly outbound: any[];
-    readonly parent?: BpmnEngineActivity | BpmnProcess;
-    readonly status: any;
-    readonly stopped: boolean;
-
-    activate(): void;
-
-    deactivate(): void;
-
-    discard(): void;
-
-    getApi(message?: any): BpmnEngineExecutionApi;
-
-    getActivityById(id: string): BpmnEngineActivity;
-
-    getState<S>(): S;
-
-    message(messageContent: any): void;
-    signal: (message?: BpmnMessage, options?: any) => void;
-    next(): void;
-
-    recover<S>(state: S): void;
-
-    resume(): void;
-
-    run(runContent?: any): void;
-
-    stop(): void;
-
-    waitFor<R>(eventName: string): Promise<R>;
   }
 
-  export interface BpmnEngineService {
-    [name: string]: Function;
-  }
-
-  export interface BpmnEngineExecutionEnvironment {
-    readonly options: any;
-    readonly extensions: BpmnEngineExtension;
-
-    readonly scripts: any;
-    readonly output: any;
-    readonly variables: BpmnEngineVariable;
-
-    readonly settings: any;
-
-    readonly Logger: BpmnLogger;
-    readonly services: BpmnEngineService;
-
-    // tslint:disable: ban-types
-    addService(name: string, serviceFn: Function): void;
-    assignVariables(...vars: any): void;
-    clone(overrideOptions?: any): BpmnEngineExecutionEnvironment;
-    getScript(scriptType: string, activity: any): any;
-    getServiceByName(name: string): any;
-
-    getState(): BpmnEngineExecutionState;
-
-    registerScript(activity: any): void;
-
-    resolveExpression<R>(
-      expression: any,
-      message?: any,
-      expressionFnContext?: any,
-    ): R;
-
-    recover(state: any): void;
-  }
-
-  export interface BpmnExecutionEventMessageContent {
-    id: string;
-    type: string;
-    executionId: string;
-    parent?: BpmnExecutionEventMessageContent;
-    path?: BpmnExecutionEventMessageContent[];
-  }
-
-  export interface BpmnExecutionEventMessageApi {
-    readonly  id: string;
-    readonly type: string;
-    readonly  name: string;
-    readonly executionId: string;
-    readonly  environment: BpmnEngineExecutionEnvironment;
-    readonly fields: any;
-
-    readonly content: BpmnExecutionEventMessageContent;
-    readonly  messageProperties: any;
-    readonly owner: BpmnEngine;
-
-    cancel(): void;
-    discard(): void;
-    signal(message: string, options: any): void;
-    stop(): void;
-
-    resolveExpression<R>(expression: any): R;
-    createMessage(overrideContent?: any): BpmnExecutionEventMessageApi;
-  }
-
-  export interface BpmnEngineExecutionDefinition extends EventEmitter {
-    state: 'pending' | 'running' | 'completed';
-    run: (callback?: any) => void;
-    resume: (callback?: any) => void;
-
-    recover: (state?: any) => void;
-
-    sendMessage: (message: any) => void;
-
-    executionId: string;
-    execution: BpmnEngineExecutionApi;
-    getProcesses: () => any[];
-
-    getExecutableProcesses: () => any[];
-    getApi: <T>(message: any) => T;
-    getElementById: (elementId: string) => any;
-    getActivityById: (childId: string) => any;
-    environment: BpmnEngineExecutionEnvironment;
-    status: string;
-    stopped: boolean;
-    type: string;
-    signal: (message: BpmnMessage, options?: any) => void;
-    cancelActivity: (message?: any) => void;
-    shake: (activityId?: string) => any;
-    broker: BpmnEngineBroker<BpmnEngine>;
-    id: string;
-    isRunning: boolean;
-    name: string;
-    logger: BpmnLogger;
-    waitFor(name: string, fn: Function): void;
-  }
-
-  export interface BpmnEngineExecutionDefinitionState {
-    readonly state: 'pending' | 'running' | 'completed';
-    readonly  processes: {
-      [processId: string]: {
-        variables: BpmnEngineVariable;
-        services: BpmnEngineService;
-        children: BpmnEngineExecutionState[];
-      };
-    };
+  interface BpmnEngineDefinitionState extends DefinitionState {
+    /**
+     * Serialized moddle-context-serializer context
+     */
+    source?: string;
   }
 
   export interface BpmnEngineExecutionState {
-    readonly name: string;
-    readonly state: 'idle' | 'running';
-    readonly stopped: boolean;
-    readonly engineVersion: string;
-    readonly environment: BpmnEngineExecutionEnvironment;
-    readonly definitions: BpmnEngineExecutionDefinitionState[];
-
-    readonly entered: boolean;
-  }
-
-  export interface BpmnEngineEventApi {
-    /**
-     * engine name
-     *
-     * @type {string}
-     *
-     */
     name: string;
-    /**
-     * state of execution, i.e running or idle
-     *
-     * @type {("running"| "idle")}
-     *
-     */
-    state: 'running' | 'idle';
-    /**
-     * is the execution stopped
-     *
-     * @type {boolean}
-     *
-     */
+    engineVersion: string;
+    state: BpmnEngineRunningStatus;
     stopped: boolean;
-    /**
-     * engine environment
-     *
-     * @type {BpmnEngineExecutionEnvironment}
-     *
-     */
-    environment: BpmnEngineExecutionEnvironment;
-
-    /**
-     * executing definitions
-     *
-     * @type {BpmnEngineExecutionDefinition}
-     *
-     */
-    definitions: BpmnEngineExecutionDefinition;
-
-    /**
-     * get execution serializable state
-     *
-     * @returns {BpmnEngineExecutionState}
-     *
-     */
-    getState(): BpmnEngineExecutionState;
-
-    /**
-     * get activities in a postponed state
-     *
-     *
-     */
-    getPostponed(): any[];
+    environment: EnvironmentState;
+    definitions: BpmnEngineDefinitionState[];
   }
 
-  export interface BpmnEngineExecutionApi {
+  export interface Execution {
     /**
      * engine name
      *
@@ -685,24 +235,26 @@ declare module 'bpmn-engine' {
     /**
      * engine environment
      *
-     * @type {BpmnEngineExecutionEnvironment}
+     * @type {Environment}
      *
      */
-    readonly environment: BpmnEngineExecutionEnvironment;
+    readonly environment: Environment;
 
     /**
      * executing definitions
      *
-     * @type {BpmnEngineExecutionDefinition}
+     * @type {Definition}
      *
      */
-    readonly definitions: BpmnEngineExecutionDefinition[];
+    readonly definitions: Definition[];
+    get activityStatus(): ActivityStatus;
 
     /**
      * Get activity/element by id. Loops the definitions and returns the first found activity with id.
      * @param activityId Activity or element id
      */
-    getActivityById(activityId: string): BpmnEngineActivity;
+    getActivityById(activityId: string): ElementBase;
+    getActivityById<R>(activityId: string): R;
 
     /**
      * get execution serializable state
@@ -724,7 +276,7 @@ declare module 'bpmn-engine' {
      *
      *
      */
-    getPostponed(): BpmnEngineActivity[];
+    getPostponed(): Api<ElementBase>[];
 
     /**
      * send signal to execution, distributed to all definitions
@@ -746,7 +298,5 @@ declare module 'bpmn-engine' {
      * @param event
      */
     waitFor<T>(event: BpmnEngineEvent): Promise<T>;
-
   }
-
 }