bpmn-engine 19.0.0 → 20.0.0

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "bpmn-engine",
   "description": "BPMN 2.0 execution engine. Open source javascript workflow engine.",
-  "version": "19.0.0",
-  "main": "index.js",
-  "types": "types/bpmn-engine.d.ts",
+  "version": "20.0.0",
+  "type": "module",
+  "module": "./src/index.js",
+  "main": "./lib/index.cjs",
+  "types": "./types/bpmn-engine.d.ts",
+  "sideEffects": false,
   "repository": {
     "type": "git",
     "url": "git://github.com/paed01/bpmn-engine"
@@ -17,18 +20,20 @@
   },
   "files": [
     "lib/",
-    "types/",
-    "index.js"
+    "src/",
+    "types/"
   ],
   "scripts": {
-    "test": "mocha -R dot",
+    "test": "mocha -p -R @bonniernews/hot-bev",
     "posttest": "npm run lint && npm run toc",
-    "lint": "eslint . --cache",
+    "lint": "eslint . --cache && prettier . -c --cache",
     "wintest": "mocha",
-    "cov:html": "c8 -r html -r text mocha -R dot",
+    "cov:html": "c8 -r html -r text mocha -p -R @bonniernews/hot-bev",
     "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"
+    "test-md": "node --experimental-vm-modules --no-warnings scripts/test-markdown.js ./docs/API.md,./docs/Examples.md,./docs/Upgrade.md",
+    "dist": "rollup -c",
+    "prepack": "npm run dist"
   },
   "keywords": [
     "workflow",
@@ -46,20 +51,25 @@
     }
   ],
   "devDependencies": {
+    "@bonniernews/hot-bev": "^0.4.0",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@types/bpmn-moddle": "^5.1.6",
     "bent": "^7.3.12",
     "c8": "^9.1.0",
     "camunda-bpmn-moddle": "^7.0.1",
-    "chai": "^4.3.7",
+    "chai": "^5.1.0",
     "chronokinesis": "^6.0.0",
     "eslint": "^8.45.0",
+    "eslint-plugin-import": "^2.29.1",
     "markdown-toc": "^1.2.0",
     "mocha": "^10.2.0",
     "mocha-cakes-2": "^3.3.0",
-    "nock": "^13.3.2"
+    "nock": "^13.3.2",
+    "prettier": "^3.2.5",
+    "rollup": "^4.10.0"
   },
   "dependencies": {
-    "@types/bpmn-moddle": "^5.1.6",
-    "bpmn-elements": "^13.1.1",
+    "bpmn-elements": "^13.1.2",
     "bpmn-moddle": "^8.0.1",
     "debug": "^4.3.4",
     "moddle-context-serializer": "^4.0.0",

package/{lib → src}/JavaScripts.js

@@ -1,16 +1,12 @@
-'use strict';
+import { Script } from 'vm';
 
-const {Script} = require('vm');
-
-module.exports = Scripts;
-
-function Scripts(disableDummy) {
+export default function Scripts(disableDummy) {
   if (!(this instanceof Scripts)) return new Scripts(disableDummy);
   this.scripts = {};
   this.disableDummy = disableDummy;
 }
 
-Scripts.prototype.register = function register({id, type, behaviour, logger, environment}) {
+Scripts.prototype.register = function register({ id, type, behaviour, logger, environment }) {
   let scriptBody, language;
 
   switch (type) {
@@ -43,20 +39,20 @@ Scripts.prototype.register = function register({id, type, behaviour, logger, env
   return script;
 };
 
-Scripts.prototype.getScript = function getScript(language, {id}) {
+Scripts.prototype.getScript = function getScript(language, { id }) {
   return this.scripts[id];
 };
 
 function JavaScript(language, filename, scriptBody, environment) {
   this.id = filename;
-  this.script = new Script(scriptBody, {filename});
+  this.script = new Script(scriptBody, { filename });
   this.language = language;
   this.environment = environment;
 }
 
 JavaScript.prototype.execute = function execute(executionContext, callback) {
   const timers = this.environment.timers.register(executionContext);
-  return this.script.runInNewContext({...executionContext, ...timers, next: callback});
+  return this.script.runInNewContext({ ...executionContext, ...timers, next: callback });
 };
 
 function DummyScript(language, filename, logger) {
@@ -67,7 +63,7 @@ function DummyScript(language, filename, logger) {
 }
 
 DummyScript.prototype.execute = function execute(executionContext, callback) {
-  const {id, executionId} = executionContext.content;
+  const { id, executionId } = executionContext.content;
   this.logger.debug(`<${executionId} (${id})> passthrough dummy script ${this.language || 'esperanto'}`);
   callback();
 };

package/{lib → src}/Logger.js

@@ -1,11 +1,9 @@
-'use strict';
+import Debug from 'debug';
 
-const Debug = require('debug');
-
-module.exports = function Logger(scope) {
+export default function Logger(scope) {
   return {
     debug: Debug('bpmn-engine:' + scope),
     error: Debug('bpmn-engine:error:' + scope),
     warn: Debug('bpmn-engine:warn:' + scope),
   };
-};
+}

package/src/extensions/ProcessOutputDataObject.js

@@ -0,0 +1,41 @@
+const kDataObjectDef = Symbol.for('data object definition');
+
+export default function ProcessOutputDataObject(dataObjectDef, { environment }) {
+  this[kDataObjectDef] = dataObjectDef;
+  this.environment = environment;
+  this.behaviour = dataObjectDef.behaviour;
+  this.name = dataObjectDef.name;
+  this.parent = dataObjectDef.parent;
+}
+
+Object.defineProperties(ProcessOutputDataObject.prototype, {
+  id: {
+    get() {
+      return this[kDataObjectDef].id;
+    },
+  },
+  type: {
+    get() {
+      return this[kDataObjectDef].type;
+    },
+  },
+});
+
+ProcessOutputDataObject.prototype.read = function readDataObject(broker, exchange, routingKeyPrefix, messageProperties) {
+  const environment = this.environment;
+  const { id, name, type } = this;
+  const value = environment.variables.data && environment.variables.data[this.id];
+  return broker.publish(exchange, `${routingKeyPrefix}response`, { id, name, type, value }, messageProperties);
+};
+
+ProcessOutputDataObject.prototype.write = function writeDataObject(broker, exchange, routingKeyPrefix, value, messageProperties) {
+  const environment = this.environment;
+  const { id, name, type } = this;
+
+  environment.variables.data = environment.variables.data || {};
+  environment.variables.data[id] = value;
+
+  environment.output.data = environment.output.data || {};
+  environment.output.data[id] = value;
+  return broker.publish(exchange, `${routingKeyPrefix}response`, { id, name, type, value }, messageProperties);
+};

package/{lib → src}/getOptionsAndCallback.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports = function getOptionsAndCallback(optionsOrCallback, callback) {
+export default function getOptionsAndCallback(optionsOrCallback, callback) {
   let options;
   if (typeof optionsOrCallback === 'function') {
     callback = optionsOrCallback;
@@ -9,4 +7,4 @@ module.exports = function getOptionsAndCallback(optionsOrCallback, callback) {
   }
 
   return [options, callback];
-};
+}

package/{index.js → src/index.js}

@@ -1,15 +1,19 @@
-'use strict';
-
-const BpmnModdle = require('bpmn-moddle');
-const Elements = require('bpmn-elements');
-const {Broker} = require('smqp');
-const {default: serializer, deserialize, TypeResolver} = require('moddle-context-serializer');
-const {EventEmitter} = require('events');
-const {version: engineVersion} = require('./package.json');
-const DebugLogger = require('./lib/Logger.js');
-const JavaScripts = require('./lib/JavaScripts.js');
-const getOptionsAndCallback = require('./lib/getOptionsAndCallback.js');
-const ProcessOutputDataObject = require('./lib/extensions/ProcessOutputDataObject.js');
+import { createRequire } from 'module';
+import { EventEmitter } from 'events';
+import { fileURLToPath } from 'url';
+
+import BpmnModdle from 'bpmn-moddle';
+import * as Elements from 'bpmn-elements';
+import { Broker } from 'smqp';
+import serializer, { deserialize, TypeResolver } from 'moddle-context-serializer';
+
+import DebugLogger from './Logger.js';
+import JavaScripts from './JavaScripts.js';
+import getOptionsAndCallback from './getOptionsAndCallback.js';
+import ProcessOutputDataObject from './extensions/ProcessOutputDataObject.js';
+
+const nodeRequire = createRequire(fileURLToPath(import.meta.url));
+const { version: engineVersion } = nodeRequire('../package.json');
 
 const kEngine = Symbol.for('engine');
 const kEnvironment = Symbol.for('environment');
@@ -23,36 +27,40 @@ const kState = Symbol.for('state');
 const kStopped = Symbol.for('stopped');
 const kTypeResolver = Symbol.for('type resolver');
 
-module.exports = {Engine, Execution};
+export default Engine;
+export { JavaScripts };
 
-function Engine(options = {}) {
+export function Engine(options = {}) {
   if (!(this instanceof Engine)) return new Engine(options);
 
   EventEmitter.call(this);
 
-  const opts = this.options = {
+  const opts = (this.options = {
     Logger: DebugLogger,
     scripts: new JavaScripts(options.disableDummyScript),
     ...options,
-  };
+  });
 
   this.logger = opts.Logger('engine');
 
-  this[kTypeResolver] = TypeResolver({
-    ...Elements,
-    ...opts.elements,
-  }, opts.typeResolver || defaultTypeResolver);
+  this[kTypeResolver] = TypeResolver(
+    {
+      ...Elements,
+      ...opts.elements,
+    },
+    opts.typeResolver || defaultTypeResolver
+  );
 
   this[kEnvironment] = new Elements.Environment(opts);
 
-  const broker = this.broker = new Broker(this);
-  broker.assertExchange('event', 'topic', {autoDelete: false});
+  const broker = (this.broker = new Broker(this));
+  broker.assertExchange('event', 'topic', { autoDelete: false });
 
   this[kExecution] = null;
   this[kLoadedDefinitions] = null;
   this[kSources] = [];
 
-  const pendingSources = this[kPendingSources] = [];
+  const pendingSources = (this[kPendingSources] = []);
   if (opts.source) pendingSources.push(this._serializeSource(opts.source));
   if (opts.moddleContext) pendingSources.push(this._serializeModdleContext(opts.moddleContext));
   if (opts.sourceContext) pendingSources.push(opts.sourceContext);
@@ -117,7 +125,7 @@ Engine.prototype.execute = async function execute(...args) {
     throw err;
   }
 
-  const execution = this[kExecution] = new Execution(this, definitions, this.options);
+  const execution = (this[kExecution] = new Execution(this, definitions, this.options));
   return execution._execute(executeOptions, callback);
 };
 
@@ -144,7 +152,7 @@ Engine.prototype.recover = function recover(savedState, recoverOptions) {
   const preSources = pendingSources.splice(0);
 
   const typeResolver = this[kTypeResolver];
-  const loadedDefinitions = this[kLoadedDefinitions] = savedState.definitions.map((dState) => {
+  const loadedDefinitions = (this[kLoadedDefinitions] = savedState.definitions.map((dState) => {
     let source;
     if (dState.source) source = deserialize(JSON.parse(dState.source), typeResolver);
     else source = preSources.find((s) => s.id === dState.id);
@@ -157,7 +165,7 @@ Engine.prototype.recover = function recover(savedState, recoverOptions) {
     definition.recover(dState);
 
     return definition;
-  });
+  }));
 
   this[kExecution] = new Execution(this, loadedDefinitions, {}, true);
 
@@ -181,16 +189,16 @@ Engine.prototype.resume = async function resume(...args) {
   return execution._resume(resumeOptions, callback);
 };
 
-Engine.prototype.addSource = function addSource({sourceContext: addContext} = {}) {
+Engine.prototype.addSource = function addSource({ sourceContext: addContext } = {}) {
   if (!addContext) return;
   const loadedDefinitions = this[kLoadedDefinitions];
   if (loadedDefinitions) loadedDefinitions.splice(0);
   this[kPendingSources].push(addContext);
 };
 
-Engine.prototype.getDefinitions = async function getDefinitions(executeOptions) {
+Engine.prototype.getDefinitions = function getDefinitions(executeOptions) {
   const loadedDefinitions = this[kLoadedDefinitions];
-  if (loadedDefinitions?.length) return loadedDefinitions;
+  if (loadedDefinitions?.length) return Promise.resolve(loadedDefinitions);
   return this._loadDefinitions(executeOptions);
 };
 
@@ -225,27 +233,30 @@ Engine.prototype.waitFor = function waitFor(eventName) {
 
 Engine.prototype._loadDefinitions = async function loadDefinitions(executeOptions) {
   const runSources = await Promise.all(this[kPendingSources]);
-  const loadedDefinitions = this[kLoadedDefinitions] = runSources.map((source) => this._loadDefinition(source, executeOptions));
+  const loadedDefinitions = (this[kLoadedDefinitions] = runSources.map((source) => this._loadDefinition(source, executeOptions)));
   return loadedDefinitions;
 };
 
 Engine.prototype._loadDefinition = function loadDefinition(serializedContext, executeOptions = {}) {
-  const {settings, variables} = executeOptions;
+  const { settings, variables } = executeOptions;
 
   const environment = this.environment;
-  const context = new Elements.Context(serializedContext, environment.clone({
-    listener: environment.options.listener,
-    ...executeOptions,
-    settings: {
-      ...environment.settings,
-      ...settings,
-    },
-    variables: {
-      ...environment.variables,
-      ...variables,
-    },
-    source: serializedContext,
-  }));
+  const context = new Elements.Context(
+    serializedContext,
+    environment.clone({
+      listener: environment.options.listener,
+      ...executeOptions,
+      settings: {
+        ...environment.settings,
+        ...settings,
+      },
+      variables: {
+        ...environment.variables,
+        ...variables,
+      },
+      source: serializedContext,
+    })
+  );
 
   return new Elements.Definition(context);
 };
@@ -266,7 +277,7 @@ Engine.prototype._getModdleContext = function getModdleContext(source) {
   return bpmnModdle.fromXML(Buffer.isBuffer(source) ? source.toString() : source.trim());
 };
 
-function Execution(engine, definitions, options, isRecovered = false) {
+export function Execution(engine, definitions, options, isRecovered = false) {
   this.name = engine.name;
   this.options = options;
   this.definitions = definitions;
@@ -275,7 +286,7 @@ function Execution(engine, definitions, options, isRecovered = false) {
   this[kEnvironment] = engine.environment;
   this[kEngine] = engine;
   this[kExecuting] = [];
-  const onBrokerReturn = this[kOnBrokerReturn] = this._onBrokerReturn.bind(this);
+  const onBrokerReturn = (this[kOnBrokerReturn] = this._onBrokerReturn.bind(this));
   engine.broker.on('return', onBrokerReturn);
 }
 
@@ -300,29 +311,10 @@ Object.defineProperties(Execution.prototype, {
       return this[kEnvironment];
     },
   },
-});
-
-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;
+  activityStatus: {
+    get() {
+      return this._getActivityStatus();
+    },
   },
 });
 
@@ -370,20 +362,35 @@ Execution.prototype._addConsumerCallbacks = function addConsumerCallbacks(callba
 
   clearConsumers();
 
-  broker.subscribeOnce('event', 'engine.stop', () => {
-    clearConsumers();
-    return callback(null, this);
-  }, {consumerTag: 'ctag-cb-stop'});
-
-  broker.subscribeOnce('event', 'engine.end', () => {
-    clearConsumers();
-    return callback(null, this);
-  }, {consumerTag: 'ctag-cb-end'});
-
-  broker.subscribeOnce('event', 'engine.error', (_, message) => {
-    clearConsumers();
-    return callback(message.content);
-  }, {consumerTag: 'ctag-cb-error'});
+  broker.subscribeOnce(
+    'event',
+    'engine.stop',
+    () => {
+      clearConsumers();
+      return callback(null, this);
+    },
+    { consumerTag: 'ctag-cb-stop' }
+  );
+
+  broker.subscribeOnce(
+    'event',
+    'engine.end',
+    () => {
+      clearConsumers();
+      return callback(null, this);
+    },
+    { consumerTag: 'ctag-cb-end' }
+  );
+
+  broker.subscribeOnce(
+    'event',
+    'engine.error',
+    (_, message) => {
+      clearConsumers();
+      return callback(message.content);
+    },
+    { consumerTag: 'ctag-cb-error' }
+  );
 
   return callback;
 
@@ -419,7 +426,7 @@ Execution.prototype._setup = function setup(setupOptions = {}) {
   for (const definition of this.definitions) {
     if (listener) definition.environment.options.listener = listener;
 
-    const {queueName} = definition.broker.subscribeTmp('event', 'definition.#', onChildMessage, {noAck: true, consumerTag: '_engine_definition'});
+    const { queueName } = definition.broker.subscribeTmp('event', 'definition.#', onChildMessage, { noAck: true, consumerTag: '_engine_definition' });
     definition.broker.bindQueue(queueName, 'event', 'process.#');
     definition.broker.bindQueue(queueName, 'event', 'activity.#');
     definition.broker.bindQueue(queueName, 'event', 'flow.#');
@@ -427,7 +434,7 @@ Execution.prototype._setup = function setup(setupOptions = {}) {
 };
 
 Execution.prototype._onChildMessage = function onChildMessage(routingKey, message, owner) {
-  const {environment: ownerEnvironment} = owner;
+  const { environment: ownerEnvironment } = owner;
   const listener = ownerEnvironment.options?.listener;
   this[kState] = 'running';
 
@@ -476,7 +483,7 @@ Execution.prototype._onChildMessage = function onChildMessage(routingKey, messag
         switch (key) {
           case 'data': {
             environment.output.data = environment.output.data || {};
-            environment.output.data = {...environment.output.data, ...message.content.output.data};
+            environment.output.data = { ...environment.output.data, ...message.content.output.data };
             break;
           }
           default: {
@@ -491,7 +498,7 @@ Execution.prototype._onChildMessage = function onChildMessage(routingKey, messag
   if (listener) listener.emit(routingKey, elementApi, this);
 
   const broker = this.broker;
-  broker.publish('event', routingKey, {...message.content}, {...message.properties, mandatory: false});
+  broker.publish('event', routingKey, { ...message.content }, { ...message.properties, mandatory: false });
 
   if (!newState) return;
 
@@ -500,13 +507,13 @@ Execution.prototype._onChildMessage = function onChildMessage(routingKey, messag
   switch (newState) {
     case 'stopped':
       this._debug('stopped');
-      return this._complete('stop', {}, {type: 'stop'});
+      return this._complete('stop', {}, { type: 'stop' });
     case 'idle':
       this._debug('completed');
-      return this._complete('end', {}, {type: 'end'});
+      return this._complete('end', {}, { type: 'end' });
     case 'error':
       this._debug('error');
-      return this._complete('error', message.content.error, {type: 'error', mandatory: true});
+      return this._complete('error', message.content.error, { type: 'error', mandatory: true });
   }
 };
 
@@ -559,7 +566,7 @@ Execution.prototype.getPostponed = function getPostponed() {
   }, []);
 };
 
-Execution.prototype.signal = function signal(payload, {ignoreSameDefinition} = {}) {
+Execution.prototype.signal = function signal(payload, { ignoreSameDefinition } = {}) {
   for (const definition of this[kExecuting]) {
     if (ignoreSameDefinition && payload?.parent?.id === definition.id) continue;
     definition.signal(payload);
@@ -585,3 +592,26 @@ Execution.prototype._onBrokerReturn = function onBrokerReturn(message) {
 Execution.prototype._debug = function debug(msg) {
   this[kEngine].logger.debug(`<${this.name}> ${msg}`);
 };
+
+Execution.prototype._getActivityStatus = function getActivityStatus() {
+  let status = 'idle';
+  const running = this[kExecuting];
+  if (!running.length) return status;
+  else if (running.length === 1) return running[0].activityStatus;
+
+  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;
+};

package/types/bpmn-engine.d.ts

@@ -4,10 +4,21 @@
 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';
+import {
+  ActivityStatus,
+  ElementBroker,
+  EnvironmentOptions,
+  Definition,
+  DefinitionState,
+  Environment,
+  Api,
+  ElementBase,
+  ILogger,
+  EnvironmentState,
+  IScripts,
+} from 'bpmn-elements';
 
 declare module 'bpmn-engine' {
-
   /**
    * Engine emits the following events:
 
@@ -30,7 +41,7 @@ declare module 'bpmn-engine' {
       activity.error: An non-recoverable error has occurred
    */
   export type BpmnActivityEvent =
-    'activity.enter'
+    | 'activity.enter'
     | 'activity.start'
     | 'activity.wait'
     | 'wait'
@@ -45,14 +56,15 @@ declare module 'bpmn-engine' {
         flow.discard: The sequence flow was discarded
         flow.looped: The sequence is looped
    */
-  export type BpmnSequenceFlowEvent = 'flow.take' | 'flow.discard' | 'flow.looped';
-  // export type BpmnEngineVariable = Record<string, any>;
-  // export type BpmnEngineSetting = Record<string, any>;
+  export type BpmnSequenceFlowEvent =
+    | 'flow.take'
+    | 'flow.discard'
+    | 'flow.looped';
 
   export interface BpmnMessage {
-    id?: string,
-    executionId?: string,
-    [name: string]: any
+    id?: string;
+    executionId?: string;
+    [name: string]: any;
   }
 
   export interface BpmnEngineExecuteOptions extends EnvironmentOptions {
@@ -147,7 +159,10 @@ declare module 'bpmn-engine' {
      */
     execute(): Promise<Execution>;
     execute(options: BpmnEngineExecuteOptions): Promise<Execution>;
-    execute(options: BpmnEngineExecuteOptions, cb: (err: Error, execution?: Execution) => void): Promise<Execution>;
+    execute(
+      options: BpmnEngineExecuteOptions,
+      cb: (err: Error, execution?: Execution) => void
+    ): Promise<Execution>;
     execute(cb: (err: Error) => void): Promise<Execution>;
 
     /**
@@ -178,7 +193,10 @@ declare module 'bpmn-engine' {
      * @param options
      * @param callback
      */
-    resume(options?: BpmnEngineExecuteOptions, callback?: (err: Error, execution?: Execution) => void): Promise<Execution>;
+    resume(
+      options?: BpmnEngineExecuteOptions,
+      callback?: (err: Error, execution?: Execution) => void
+    ): Promise<Execution>;
 
     /**
      * Stop execution. The instance is terminated.
@@ -284,7 +302,10 @@ declare module 'bpmn-engine' {
      * @param message {BpmnMessage}
      * @param options
      */
-    signal(message?: BpmnMessage, options?: { ignoreSameDefinition?: boolean }): void;
+    signal(
+      message?: BpmnMessage,
+      options?: { ignoreSameDefinition?: boolean }
+    ): void;
 
     /**
      * send cancel activity to execution, distributed to all definitions
@@ -299,4 +320,16 @@ declare module 'bpmn-engine' {
      */
     waitFor<T>(event: BpmnEngineEvent): Promise<T>;
   }
+
+  export class JavaScripts implements IScripts {
+    /**
+     * @param disableDummy Disable returning dummy scripts if script is not found. Dummy script will immediately call next function without error or return value
+     */
+    constructor(disableDummy?: boolean);
+    register(activity: any): Script | undefined;
+    getScript(
+      language: string,
+      identifier: { id: string; [x: string]: any }
+    ): Script;
+  }
 }