@nocobase/plugin-workflow 0.7.0-alpha.9 → 0.7.1-alpha.6

package/lib/instructions/prompt.js

@@ -1,15 +1,23 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-exports.default = {
-    run(input, execution) {
-        return {
-            status: constants_1.JOB_STATUS.PENDING
-        };
-    },
-    resume(job, execution) {
-        job.set('status', constants_1.JOB_STATUS.RESOLVED);
-        return job;
-    }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../constants");
+
+var _default = {
+  run(node, input, processor) {
+    return {
+      status: _constants.JOB_STATUS.PENDING
+    };
+  },
+
+  resume(node, job, processor) {
+    job.set('status', _constants.JOB_STATUS.RESOLVED);
+    return job;
+  }
+
 };
-//# sourceMappingURL=prompt.js.map
+exports.default = _default;

package/lib/instructions/query.d.ts

@@ -1,6 +1,7 @@
 import FlowNodeModel from "../models/FlowNode";
+import Processor from "../Processor";
 declare const _default: {
-    run(this: FlowNodeModel, input: any, execution: any): Promise<{
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
         result: any;
         status: number;
     }>;

package/lib/instructions/query.js

@@ -1,27 +1,44 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../constants");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var _default = {
+  run(node, input, processor) {
+    return _asyncToGenerator(function* () {
+      const _node$config = node.config,
+            collection = _node$config.collection,
+            multiple = _node$config.multiple,
+            _node$config$params = _node$config.params,
+            params = _node$config$params === void 0 ? {} : _node$config$params;
+      const repo = node.constructor.database.getRepository(collection);
+      const options = processor.getParsedValue(params);
+      const result = yield (multiple ? repo.find : repo.findOne).call(repo, _objectSpread(_objectSpread({}, options), {}, {
+        transaction: processor.transaction
+      })); // NOTE: `toJSON()` to avoid getting undefined value from Proxied model instance (#380)
+      // e.g. Object.prototype.hasOwnProperty.call(result, 'id') // false
+      // so the properties can not be get by json-templates(object-path)
+
+      return {
+        result: multiple ? result.map(item => item.toJSON()) : result === null || result === void 0 ? void 0 : result.toJSON(),
+        status: _constants.JOB_STATUS.RESOLVED
+      };
+    })();
+  }
+
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-exports.default = {
-    run(input, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { collection, multiple, params = {} } = this.config;
-            const repo = this.constructor.database.getRepository(collection);
-            const options = execution.getParsedValue(params);
-            const result = yield (multiple ? repo.find : repo.findOne).call(repo, Object.assign(Object.assign({}, options), { transaction: execution.transaction }));
-            return {
-                result,
-                status: constants_1.JOB_STATUS.RESOLVED
-            };
-        });
-    }
-};
-//# sourceMappingURL=query.js.map
+exports.default = _default;

package/lib/instructions/update.d.ts

@@ -1,6 +1,7 @@
 import FlowNodeModel from "../models/FlowNode";
+import Processor from "../Processor";
 declare const _default: {
-    run(this: FlowNodeModel, input: any, execution: any): Promise<{
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
         result: import("@nocobase/database").Model<any, any> | import("@nocobase/database").Model<any, any>[];
         status: number;
     }>;

package/lib/instructions/update.js

@@ -1,27 +1,42 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../constants");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var _default = {
+  run(node, input, processor) {
+    return _asyncToGenerator(function* () {
+      const _node$config = node.config,
+            collection = _node$config.collection,
+            _node$config$multiple = _node$config.multiple,
+            multiple = _node$config$multiple === void 0 ? false : _node$config$multiple,
+            _node$config$params = _node$config.params,
+            params = _node$config$params === void 0 ? {} : _node$config$params;
+      const repo = node.constructor.database.getRepository(collection);
+      const options = processor.getParsedValue(params);
+      const result = yield repo.update(_objectSpread(_objectSpread({}, options), {}, {
+        transaction: processor.transaction
+      }));
+      return {
+        result: multiple ? result : result[0] || null,
+        status: _constants.JOB_STATUS.RESOLVED
+      };
+    })();
+  }
+
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-exports.default = {
-    run(input, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { collection, multiple = false, params = {} } = this.config;
-            const repo = this.constructor.database.getRepository(collection);
-            const options = execution.getParsedValue(params);
-            const result = yield repo.update(Object.assign(Object.assign({}, options), { transaction: execution.transaction }));
-            return {
-                result: multiple ? result : (result[0] || null),
-                status: constants_1.JOB_STATUS.RESOLVED
-            };
-        });
-    }
-};
-//# sourceMappingURL=update.js.map
+exports.default = _default;

package/lib/models/Execution.d.ts

@@ -1,11 +1,7 @@
 import { Database, Model } from '@nocobase/database';
-import { BelongsToGetAssociationMixin, HasManyGetAssociationsMixin, Transaction } from 'sequelize';
+import { BelongsToGetAssociationMixin, HasManyGetAssociationsMixin } from 'sequelize';
 import WorkflowModel from './Workflow';
-import FlowNodeModel from './FlowNode';
 import JobModel from './Job';
-export interface ExecutionOptions {
-    transaction?: Transaction;
-}
 export default class ExecutionModel extends Model {
     static readonly database: Database;
     id: number;
@@ -13,38 +9,12 @@ export default class ExecutionModel extends Model {
     context: any;
     status: number;
     useTransaction: boolean;
+    transaction: string;
     createdAt: Date;
     updatedAt: Date;
+    key: string;
     workflow?: WorkflowModel;
     getWorkflow: BelongsToGetAssociationMixin<WorkflowModel>;
     jobs?: JobModel[];
     getJobs: HasManyGetAssociationsMixin<JobModel>;
-    options: ExecutionOptions;
-    transaction: Transaction;
-    nodes: Array<FlowNodeModel>;
-    nodesMap: Map<number, FlowNodeModel>;
-    jobsMap: Map<number, JobModel>;
-    jobsMapByNodeId: {
-        [key: number]: any;
-    };
-    static StatusMap: {
-        [x: number]: number;
-    };
-    makeNodes(nodes?: any[]): void;
-    makeJobs(jobs: Array<JobModel>): void;
-    getTransaction(): Transaction | Promise<Transaction>;
-    prepare(options: any, commit?: boolean): Promise<void>;
-    start(options: ExecutionOptions): Promise<void>;
-    resume(job: JobModel, options: ExecutionOptions): Promise<void>;
-    private commit;
-    private exec;
-    run(node: any, input?: any): any;
-    end(node: any, job: any): any;
-    recall(node: any, job: any): any;
-    exit(job: JobModel | null): Promise<any>;
-    saveJob(payload: any): Promise<JobModel>;
-    findBranchStartNode(node: FlowNodeModel): FlowNodeModel | null;
-    findBranchParentNode(node: FlowNodeModel): FlowNodeModel | null;
-    findBranchParentJob(job: JobModel, node: FlowNodeModel): JobModel | null;
-    getParsedValue(value: any, node?: any): any;
 }

package/lib/models/Execution.js

@@ -1,256 +1,20 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const database_1 = require("@nocobase/database");
-const json_templates_1 = __importDefault(require("json-templates"));
-const constants_1 = require("../constants");
-const instructions_1 = __importDefault(require("../instructions"));
-const calculators_1 = __importDefault(require("../calculators"));
-class ExecutionModel extends database_1.Model {
-    constructor() {
-        super(...arguments);
-        this.nodes = [];
-        this.nodesMap = new Map();
-        this.jobsMap = new Map();
-        this.jobsMapByNodeId = {};
-    }
-    // make dual linked nodes list then cache
-    makeNodes(nodes = []) {
-        this.nodes = nodes;
-        nodes.forEach((node) => {
-            this.nodesMap.set(node.id, node);
-        });
-        nodes.forEach((node) => {
-            if (node.upstreamId) {
-                node.upstream = this.nodesMap.get(node.upstreamId);
-            }
-            if (node.downstreamId) {
-                node.downstream = this.nodesMap.get(node.downstreamId);
-            }
-        });
-    }
-    makeJobs(jobs) {
-        jobs.forEach((job) => {
-            this.jobsMap.set(job.id, job);
-            // TODO: should consider cycle, and from previous job
-            this.jobsMapByNodeId[job.nodeId] = job.result;
-        });
-    }
-    getTransaction() {
-        const { sequelize } = this.constructor.database;
-        // @ts-ignore
-        if (!this.useTransaction) {
-            return undefined;
-        }
-        const { options } = this;
-        // @ts-ignore
-        return options.transaction && !options.transaction.finished
-            ? options.transaction
-            : sequelize.transaction();
-    }
-    prepare(options, commit = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.options = options || {};
-            // @ts-ignore
-            const transaction = yield this.getTransaction();
-            this.transaction = transaction;
-            if (!this.workflow) {
-                this.workflow = yield this.getWorkflow({ transaction });
-            }
-            const nodes = yield this.workflow.getNodes({ transaction });
-            this.makeNodes(nodes);
-            const jobs = yield this.getJobs({
-                order: [['id', 'ASC']],
-                transaction,
-            });
-            this.makeJobs(jobs);
-            if (commit) {
-                yield this.commit();
-            }
-        });
-    }
-    start(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.status !== constants_1.EXECUTION_STATUS.STARTED) {
-                throw new Error(`execution was ended with status ${this.status}`);
-            }
-            yield this.prepare(options);
-            if (this.nodes.length) {
-                const head = this.nodes.find(item => !item.upstream);
-                yield this.run(head, { result: this.context });
-            }
-            else {
-                yield this.exit(null);
-            }
-            yield this.commit();
-        });
-    }
-    resume(job, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.status !== constants_1.EXECUTION_STATUS.STARTED) {
-                throw new Error(`execution was ended with status ${this.status}`);
-            }
-            yield this.prepare(options);
-            const node = this.nodesMap.get(job.nodeId);
-            yield this.recall(node, job);
-            yield this.commit();
-        });
-    }
-    commit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // @ts-ignore
-            if (this.transaction && (!this.options.transaction || this.options.transaction.finished)) {
-                yield this.transaction.commit();
-            }
-        });
-    }
-    exec(instruction, node, prevJob) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let job;
-            try {
-                // call instruction to get result and status
-                job = yield instruction.call(node, prevJob, this);
-                if (!job) {
-                    return null;
-                }
-            }
-            catch (err) {
-                // for uncaught error, set to rejected
-                job = {
-                    result: err instanceof Error
-                        ? { message: err.message, stack: process.env.NODE_ENV === 'production' ? [] : err.stack }
-                        : err,
-                    status: constants_1.JOB_STATUS.REJECTED,
-                };
-                // if previous job is from resuming
-                if (prevJob && prevJob.nodeId === node.id) {
-                    prevJob.set(job);
-                    job = prevJob;
-                }
-            }
-            let savedJob;
-            // TODO(optimize): many checking of resuming or new could be improved
-            // could be implemented separately in exec() / resume()
-            if (job instanceof database_1.Model) {
-                savedJob = (yield job.save({ transaction: this.transaction }));
-            }
-            else {
-                const upstreamId = prevJob instanceof database_1.Model ? prevJob.get('id') : null;
-                savedJob = yield this.saveJob(Object.assign({ nodeId: node.id, upstreamId }, job));
-            }
-            if (savedJob.status === constants_1.JOB_STATUS.RESOLVED && node.downstream) {
-                // run next node
-                return this.run(node.downstream, savedJob);
-            }
-            // all nodes in scope have been executed
-            return this.end(node, savedJob);
-        });
-    }
-    run(node, input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { run } = instructions_1.default.get(node.type);
-            if (typeof run !== 'function') {
-                return Promise.reject(new Error('`run` should be implemented for customized execution of the node'));
-            }
-            return this.exec(run, node, input);
-        });
-    }
-    // parent node should take over the control
-    end(node, job) {
-        const parentNode = this.findBranchParentNode(node);
-        // no parent, means on main flow
-        if (parentNode) {
-            return this.recall(parentNode, job);
-        }
-        // really done for all nodes
-        // * should mark execution as done with last job status
-        return this.exit(job);
-    }
-    recall(node, job) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { resume } = instructions_1.default.get(node.type);
-            if (typeof resume !== 'function') {
-                return Promise.reject(new Error('`resume` should be implemented because the node made branch'));
-            }
-            return this.exec(resume, node, job);
-        });
-    }
-    exit(job) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const status = job ? ExecutionModel.StatusMap[job.status] : constants_1.EXECUTION_STATUS.RESOLVED;
-            yield this.update({ status }, { transaction: this.transaction });
-            return null;
-        });
-    }
-    // TODO(optimize)
-    saveJob(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { database } = this.constructor;
-            const { model } = database.getCollection('jobs');
-            const [job] = (yield model.upsert(Object.assign(Object.assign({}, payload), { executionId: this.id }), { transaction: this.transaction }));
-            this.jobsMap.set(job.id, job);
-            this.jobsMapByNodeId[job.nodeId] = job.result;
-            return job;
-        });
-    }
-    // find the first node in current branch
-    findBranchStartNode(node) {
-        for (let n = node; n; n = n.upstream) {
-            if (n.branchIndex !== null) {
-                return n;
-            }
-        }
-        return null;
-    }
-    // find the node start current branch
-    findBranchParentNode(node) {
-        for (let n = node; n; n = n.upstream) {
-            if (n.branchIndex !== null) {
-                return n.upstream;
-            }
-        }
-        return null;
-    }
-    findBranchParentJob(job, node) {
-        for (let j = job; j; j = this.jobsMap.get(j.upstreamId)) {
-            if (j.nodeId === node.id) {
-                return j;
-            }
-        }
-        return null;
-    }
-    getParsedValue(value, node) {
-        const injectedFns = {};
-        const scope = {
-            execution: this,
-            node
-        };
-        for (let [name, fn] of calculators_1.default.getEntities()) {
-            injectedFns[name] = fn.bind(scope);
-        }
-        return (0, json_templates_1.default)(value)({
-            $context: this.context,
-            $jobsMapByNodeId: this.jobsMapByNodeId,
-            $fn: injectedFns
-        });
-    }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
 }
-exports.default = ExecutionModel;
-ExecutionModel.StatusMap = {
-    [constants_1.JOB_STATUS.PENDING]: constants_1.EXECUTION_STATUS.STARTED,
-    [constants_1.JOB_STATUS.RESOLVED]: constants_1.EXECUTION_STATUS.RESOLVED,
-    [constants_1.JOB_STATUS.REJECTED]: constants_1.EXECUTION_STATUS.REJECTED,
-    [constants_1.JOB_STATUS.CANCELLED]: constants_1.EXECUTION_STATUS.CANCELLED,
-};
-//# sourceMappingURL=Execution.js.map
+
+class ExecutionModel extends _database().Model {}
+
+exports.default = ExecutionModel;

package/lib/models/FlowNode.js

@@ -1,7 +1,20 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const database_1 = require("@nocobase/database");
-class FlowNodeModel extends database_1.Model {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
 }
-exports.default = FlowNodeModel;
-//# sourceMappingURL=FlowNode.js.map
+
+class FlowNodeModel extends _database().Model {}
+
+exports.default = FlowNodeModel;

package/lib/models/Job.js

@@ -1,7 +1,20 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const database_1 = require("@nocobase/database");
-class JobModel extends database_1.Model {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
 }
-exports.default = JobModel;
-//# sourceMappingURL=Job.js.map
+
+class JobModel extends _database().Model {}
+
+exports.default = JobModel;

package/lib/models/Workflow.d.ts

@@ -1,27 +1,26 @@
 import { Database, Model } from '@nocobase/database';
-import { HasManyCreateAssociationMixin, HasManyGetAssociationsMixin } from 'sequelize';
+import { HasManyCountAssociationsMixin, HasManyCreateAssociationMixin, HasManyGetAssociationsMixin } from 'sequelize';
 import ExecutionModel from './Execution';
 import FlowNodeModel from './FlowNode';
 export default class WorkflowModel extends Model {
     static database: Database;
     id: number;
+    key: string;
     title: string;
     enabled: boolean;
+    current: boolean;
     description?: string;
     type: string;
     config: any;
     useTransaction: boolean;
+    executed: number;
     createdAt: Date;
     updatedAt: Date;
     nodes: FlowNodeModel[];
     getNodes: HasManyGetAssociationsMixin<FlowNodeModel>;
     createNode: HasManyCreateAssociationMixin<FlowNodeModel>;
     executions: ExecutionModel[];
+    countExecutions: HasManyCountAssociationsMixin;
     getExecutions: HasManyGetAssociationsMixin<ExecutionModel>;
     createExecution: HasManyCreateAssociationMixin<ExecutionModel>;
-    static mount(): Promise<void>;
-    getHookId(): string;
-    getTransaction(options: any): any;
-    toggle(enable?: boolean): Promise<void>;
-    trigger(context: Object, options: any): Promise<ExecutionModel>;
 }