@nocobase/plugin-workflow 0.7.0-alpha.83 → 0.7.1-alpha.5

package/lib/models/Execution.js

@@ -15,401 +15,6 @@ function _database() {
   return data;
 }
 
-function _jsonTemplates() {
-  const data = _interopRequireDefault(require("json-templates"));
+class ExecutionModel extends _database().Model {}
 
-  _jsonTemplates = function _jsonTemplates() {
-    return data;
-  };
-
-  return data;
-}
-
-var _constants = require("../constants");
-
-var _instructions = _interopRequireDefault(require("../instructions"));
-
-var _calculators = _interopRequireDefault(require("../calculators"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-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); }); }; }
-
-class ExecutionModel extends _database().Model {
-  constructor(...args) {
-    super(...args);
-    this.options = void 0;
-    this.tx = void 0;
-    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() {
-    var _this = this;
-
-    return _asyncToGenerator(function* () {
-      const sequelize = _this.constructor.database.sequelize;
-
-      if (!_this.useTransaction) {
-        return undefined;
-      }
-
-      const options = _this.options; // @ts-ignore
-
-      const transaction = options.transaction && !options.transaction.finished ? options.transaction : sequelize.transaction(); // @ts-ignore
-
-      if (_this.transaction !== transaction.id) {
-        // @ts-ignore
-        yield _this.update({
-          transaction: transaction.id
-        }, {
-          transaction
-        });
-      }
-
-      return transaction;
-    })();
-  }
-
-  prepare(options, commit = false) {
-    var _this2 = this;
-
-    return _asyncToGenerator(function* () {
-      _this2.options = options || {};
-      const transaction = yield _this2.getTransaction();
-      _this2.tx = transaction;
-
-      if (!_this2.workflow) {
-        _this2.workflow = yield _this2.getWorkflow({
-          transaction
-        });
-      }
-
-      const nodes = yield _this2.workflow.getNodes({
-        transaction
-      });
-
-      _this2.makeNodes(nodes);
-
-      const jobs = yield _this2.getJobs({
-        order: [['id', 'ASC']],
-        transaction
-      });
-
-      _this2.makeJobs(jobs);
-
-      if (commit) {
-        yield _this2.commit();
-      }
-    })();
-  }
-
-  start(options) {
-    var _this3 = this;
-
-    return _asyncToGenerator(function* () {
-      if (_this3.status !== _constants.EXECUTION_STATUS.STARTED) {
-        throw new Error(`execution was ended with status ${_this3.status}`);
-      }
-
-      yield _this3.prepare(options);
-
-      if (_this3.nodes.length) {
-        const head = _this3.nodes.find(item => !item.upstream);
-
-        yield _this3.run(head, {
-          result: _this3.context
-        });
-      } else {
-        yield _this3.exit(null);
-      }
-
-      yield _this3.commit();
-    })();
-  }
-
-  resume(job, options) {
-    var _this4 = this;
-
-    return _asyncToGenerator(function* () {
-      if (_this4.status !== _constants.EXECUTION_STATUS.STARTED) {
-        throw new Error(`execution was ended with status ${_this4.status}`);
-      }
-
-      yield _this4.prepare(options);
-
-      const node = _this4.nodesMap.get(job.nodeId);
-
-      yield _this4.recall(node, job);
-      yield _this4.commit();
-    })();
-  }
-
-  commit() {
-    var _this5 = this;
-
-    return _asyncToGenerator(function* () {
-      // @ts-ignore
-      if (_this5.tx && (!_this5.options.transaction || _this5.options.transaction.finished)) {
-        yield _this5.tx.commit();
-      }
-    })();
-  }
-
-  exec(instruction, node, prevJob) {
-    var _this6 = this;
-
-    return _asyncToGenerator(function* () {
-      let job;
-
-      try {
-        // call instruction to get result and status
-        job = yield instruction.call(node, prevJob, _this6);
-
-        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.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().Model) {
-        savedJob = yield job.save({
-          transaction: _this6.tx
-        });
-      } else {
-        const upstreamId = prevJob instanceof _database().Model ? prevJob.get('id') : null;
-        savedJob = yield _this6.saveJob(_objectSpread({
-          nodeId: node.id,
-          upstreamId
-        }, job));
-      }
-
-      if (savedJob.status === _constants.JOB_STATUS.RESOLVED && node.downstream) {
-        // run next node
-        return _this6.run(node.downstream, savedJob);
-      } // all nodes in scope have been executed
-
-
-      return _this6.end(node, savedJob);
-    })();
-  }
-
-  run(node, input) {
-    var _this7 = this;
-
-    return _asyncToGenerator(function* () {
-      const _instructions$get = _instructions.default.get(node.type),
-            run = _instructions$get.run;
-
-      if (typeof run !== 'function') {
-        return Promise.reject(new Error('`run` should be implemented for customized execution of the node'));
-      }
-
-      return _this7.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) {
-    var _this8 = this;
-
-    return _asyncToGenerator(function* () {
-      const _instructions$get2 = _instructions.default.get(node.type),
-            resume = _instructions$get2.resume;
-
-      if (typeof resume !== 'function') {
-        return Promise.reject(new Error('`resume` should be implemented because the node made branch'));
-      }
-
-      return _this8.exec(resume, node, job);
-    })();
-  }
-
-  exit(job) {
-    var _this9 = this;
-
-    return _asyncToGenerator(function* () {
-      const status = job ? ExecutionModel.StatusMap[job.status] : _constants.EXECUTION_STATUS.RESOLVED;
-      yield _this9.update({
-        status
-      }, {
-        transaction: _this9.tx
-      });
-      return null;
-    })();
-  } // TODO(optimize)
-
-
-  saveJob(payload) {
-    var _this10 = this;
-
-    return _asyncToGenerator(function* () {
-      const database = _this10.constructor.database;
-
-      const _database$getCollecti = database.getCollection('jobs'),
-            model = _database$getCollecti.model;
-
-      const _yield$model$upsert = yield model.upsert(_objectSpread(_objectSpread({}, payload), {}, {
-        executionId: _this10.id
-      }), {
-        transaction: _this10.tx
-      }),
-            _yield$model$upsert2 = _slicedToArray(_yield$model$upsert, 1),
-            job = _yield$model$upsert2[0];
-
-      _this10.jobsMap.set(job.id, job);
-
-      _this10.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
-    };
-
-    var _iterator = _createForOfIteratorHelper(_calculators.default.getEntities()),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        let _step$value = _slicedToArray(_step.value, 2),
-            name = _step$value[0],
-            fn = _step$value[1];
-
-        injectedFns[name] = fn.bind(scope);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-
-    return (0, _jsonTemplates().default)(value)({
-      $context: this.context,
-      $jobsMapByNodeId: this.jobsMapByNodeId,
-      $fn: injectedFns
-    });
-  }
-
-}
-
-exports.default = ExecutionModel;
-ExecutionModel.StatusMap = {
-  [_constants.JOB_STATUS.PENDING]: _constants.EXECUTION_STATUS.STARTED,
-  [_constants.JOB_STATUS.RESOLVED]: _constants.EXECUTION_STATUS.RESOLVED,
-  [_constants.JOB_STATUS.REJECTED]: _constants.EXECUTION_STATUS.REJECTED,
-  [_constants.JOB_STATUS.CANCELLED]: _constants.EXECUTION_STATUS.CANCELLED
-};
+exports.default = ExecutionModel;

package/lib/models/Workflow.d.ts

@@ -5,8 +5,10 @@ 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;
@@ -21,6 +23,4 @@ export default class WorkflowModel extends Model {
     countExecutions: HasManyCountAssociationsMixin;
     getExecutions: HasManyGetAssociationsMixin<ExecutionModel>;
     createExecution: HasManyCreateAssociationMixin<ExecutionModel>;
-    getTransaction(options: any): any;
-    trigger: (context: Object, options?: {}) => Promise<ExecutionModel>;
 }

package/lib/models/Workflow.js

@@ -15,86 +15,6 @@ function _database() {
   return data;
 }
 
-var _constants = require("../constants");
-
-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); }); }; }
-
-class WorkflowModel extends _database().Model {
-  constructor(...args) {
-    var _this;
-
-    super(...args);
-    _this = this;
-
-    this.trigger = /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator(function* (context, options = {}) {
-        // `null` means not to trigger
-        if (context === null) {
-          return;
-        }
-
-        const transaction = yield _this.getTransaction(options);
-
-        if (_this.useTransaction) {
-          const existed = yield _this.countExecutions({
-            where: {
-              transaction: transaction.id
-            },
-            transaction
-          });
-
-          if (existed) {
-            console.warn(`workflow ${_this.id} has already been triggered in same execution (${transaction.id}), and newly triggering will be skipped.`);
-            return;
-          }
-        }
-
-        const execution = yield _this.createExecution({
-          context,
-          status: _constants.EXECUTION_STATUS.STARTED,
-          useTransaction: _this.useTransaction,
-          transaction: transaction.id
-        }, {
-          transaction
-        });
-        const executed = yield _this.countExecutions({
-          transaction
-        }); // NOTE: not to trigger afterUpdate hook here
-
-        yield _this.update({
-          executed
-        }, {
-          transaction,
-          hooks: false
-        });
-        execution.workflow = _this;
-        yield execution.start({
-          transaction
-        }); // @ts-ignore
-
-        if (transaction && (!options.transaction || options.transaction.finished)) {
-          yield transaction.commit();
-        }
-
-        return execution;
-      });
-
-      return function (_x) {
-        return _ref.apply(this, arguments);
-      };
-    }();
-  }
-
-  getTransaction(options) {
-    if (!this.useTransaction) {
-      return null;
-    }
-
-    return options.transaction && !options.transaction.finished ? options.transaction : this.constructor.database.sequelize.transaction();
-  }
-
-}
+class WorkflowModel extends _database().Model {}
 
 exports.default = WorkflowModel;

package/lib/triggers/collection.d.ts

@@ -1,16 +1,12 @@
-import { Trigger } from ".";
+import { Trigger } from "..";
 import WorkflowModel from "../models/Workflow";
 export interface CollectionChangeTriggerConfig {
     collection: string;
     mode: number;
     condition: any;
 }
-export default class CollectionTrigger implements Trigger {
-    db: any;
+export default class CollectionTrigger extends Trigger {
     events: Map<any, any>;
-    constructor({ app }: {
-        app: any;
-    });
     on(workflow: WorkflowModel): void;
     off(workflow: WorkflowModel): void;
 }

package/lib/triggers/collection.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _ = require("..");
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -19,6 +21,10 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 
+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); }); }; }
+
 const MODE_BITMAP = {
   CREATE: 1,
   UPDATE: 2,
@@ -34,39 +40,67 @@ function getHookId(workflow, type) {
 } // async function, should return promise
 
 
-function handler(data, options) {
-  const _this$config = this.config,
-        condition = _this$config.condition,
-        changed = _this$config.changed; // NOTE: if no configured fields changed, do not trigger
-
-  if (changed && changed.length && changed.every(name => !data.changed(name))) {
-    return;
-  } // NOTE: if no configured condition match, do not trigger
-
+function handler(_x, _x2, _x3) {
+  return _handler.apply(this, arguments);
+}
 
-  if (condition && condition.$and.length) {// TODO: check all conditions in condition against data
-    // const calculation = toCalculation(condition);
-  }
+function _handler() {
+  _handler = _asyncToGenerator(function* (workflow, data, options) {
+    var _condition$$and;
+
+    const _workflow$config3 = workflow.config,
+          collection = _workflow$config3.collection,
+          condition = _workflow$config3.condition,
+          changed = _workflow$config3.changed; // NOTE: if no configured fields changed, do not trigger
+
+    if (changed && changed.length && changed.every(name => !data.changed(name))) {// TODO: temp comment out
+      // return;
+    } // NOTE: if no configured condition match, do not trigger
+
+
+    if (condition && ((_condition$$and = condition.$and) === null || _condition$$and === void 0 ? void 0 : _condition$$and.length)) {
+      // TODO: change to map filter format to calculation format
+      // const calculation = toCalculation(condition);
+      const _data$constructor$dat = data.constructor.database.getCollection(collection),
+            repository = _data$constructor$dat.repository,
+            model = _data$constructor$dat.model;
+
+      const transaction = options.transaction;
+      const count = yield repository.count({
+        filter: {
+          $and: [condition, {
+            [model.primaryKeyAttribute]: data[model.primaryKeyAttribute]
+          }]
+        },
+        transaction
+      });
+
+      if (!count) {
+        return;
+      }
+    }
 
-  return this.trigger({
-    data: data.get()
-  }, options);
+    return this.plugin.trigger(workflow, {
+      data: data.get()
+    }, {
+      transaction: options.transaction
+    });
+  });
+  return _handler.apply(this, arguments);
 }
 
-class CollectionTrigger {
-  constructor({
-    app
-  }) {
-    this.db = void 0;
+class CollectionTrigger extends _.Trigger {
+  constructor(...args) {
+    super(...args);
     this.events = new Map();
-    this.db = app.db;
   }
 
   on(workflow) {
+    const db = this.plugin.app.db;
     const _workflow$config = workflow.config,
           collection = _workflow$config.collection,
           mode = _workflow$config.mode;
-    const Collection = this.db.getCollection(collection);
+    const Collection = db.getCollection(collection);
 
     if (!Collection) {
       return;
@@ -86,15 +120,15 @@ class CollectionTrigger {
 
         if (mode & key) {
           if (!this.events.has(name)) {
-            const listener = handler.bind(workflow);
+            const listener = handler.bind(this, workflow);
             this.events.set(name, listener);
-            this.db.on(event, listener);
+            db.on(event, listener);
           }
         } else {
           const listener = this.events.get(name);
 
           if (listener) {
-            this.db.off(event, listener);
+            db.off(event, listener);
             this.events.delete(name);
           }
         }
@@ -107,10 +141,11 @@ class CollectionTrigger {
   }
 
   off(workflow) {
+    const db = this.plugin.app.db;
     const _workflow$config2 = workflow.config,
           collection = _workflow$config2.collection,
           mode = _workflow$config2.mode;
-    const Collection = this.db.getCollection(collection);
+    const Collection = db.getCollection(collection);
 
     if (!Collection) {
       return;
@@ -132,7 +167,7 @@ class CollectionTrigger {
           const listener = this.events.get(name);
 
           if (listener) {
-            this.db.off(event, listener);
+            db.off(event, listener);
             this.events.delete(name);
           }
         }

package/lib/triggers/index.d.ts

@@ -1,6 +1,13 @@
+import Plugin from '..';
 import WorkflowModel from '../models/Workflow';
-export interface Trigger {
-    on(workflow: WorkflowModel): void;
-    off(workflow: WorkflowModel): void;
+export declare abstract class Trigger {
+    readonly plugin: Plugin;
+    constructor(plugin: Plugin);
+    abstract on(workflow: WorkflowModel): void;
+    abstract off(workflow: WorkflowModel): void;
 }
-export default function (plugin: any): void;
+export default function <T extends Trigger>(plugin: any, more?: {
+    [key: string]: {
+        new (p: Plugin): T;
+    };
+}): void;