@tachybase/module-workflow 0.23.8

package/dist/server/features/webhook/webhooks.js

@@ -0,0 +1,286 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webhooks_exports = {};
+__export(webhooks_exports, {
+  WebhookController: () => WebhookController
+});
+module.exports = __toCommonJS(webhooks_exports);
+var import_utils = require("@tachybase/utils");
+var import_lodash = __toESM(require("lodash"));
+var import__ = require("../..");
+function isSameBasic(val1, val2) {
+  if (val1 instanceof Date || val2 instanceof Date) {
+    return new Date(val1).getTime() === new Date(val2).getTime();
+  }
+  return val1 === val2;
+}
+function getLostKey(smallOne, bigOne, path = "") {
+  const lostKeys = /* @__PURE__ */ new Set();
+  if (typeof bigOne !== "object" || bigOne === null) {
+    if (smallOne === void 0) {
+      return [path];
+    }
+    return [];
+  }
+  const bigKeys = Object.keys(bigOne);
+  for (const key of bigKeys) {
+    let keyLabel = path ? `${path}.${key}` : key;
+    if (Array.isArray(bigOne)) {
+      keyLabel = path;
+    }
+    if ((smallOne == null ? void 0 : smallOne[key]) === void 0) {
+      lostKeys.add(keyLabel);
+      continue;
+    } else {
+      const result = getLostKey(smallOne == null ? void 0 : smallOne[key], bigOne == null ? void 0 : bigOne[key], keyLabel);
+      for (const item of result) {
+        lostKeys.add(item);
+      }
+    }
+  }
+  return [...lostKeys];
+}
+function getDiffKeyExceptAfter(before, after, path = "") {
+  if (after === null || after === void 0) {
+    return [];
+  }
+  if (typeof before !== "object" || typeof after !== "object" || before === null || after === null) {
+    if (!isSameBasic(before, after)) {
+      return [path];
+    } else {
+      return [];
+    }
+  }
+  if (Array.isArray(before) && Array.isArray(after) && before.length !== after.length) {
+    return [path];
+  }
+  const beforeDiffKeys = /* @__PURE__ */ new Set();
+  const beforeKeys = Object.keys(before);
+  for (const key of beforeKeys) {
+    if ((after == null ? void 0 : after[key]) === void 0) {
+      continue;
+    }
+    let keyLabel = path ? `${path}.${key}` : key;
+    if (Array.isArray(after)) {
+      keyLabel = path;
+    }
+    if ((before == null ? void 0 : before[key]) === void 0) {
+      beforeDiffKeys.add(keyLabel);
+      continue;
+    } else {
+      const result = getDiffKeyExceptAfter(before == null ? void 0 : before[key], after == null ? void 0 : after[key], keyLabel);
+      for (const item of result) {
+        beforeDiffKeys.add(item);
+      }
+    }
+  }
+  return [...beforeDiffKeys];
+}
+function getChanged(ctx) {
+  return async function() {
+    try {
+      const params = import_lodash.default.cloneDeep(ctx.action.params);
+      const repo = ctx.db.getRepository(ctx.action.resourceName);
+      const fieldsObj = {};
+      const app = ctx.app;
+      const c = app.mainDataSource.collectionManager.getCollection(ctx.action.resourceName);
+      const fields = c.getFields();
+      for (const field of fields) {
+        fieldsObj[field.options.name] = field;
+      }
+      let appendSet = /* @__PURE__ */ new Set();
+      if (params.updateAssociationValues) {
+        appendSet = new Set(params.updateAssociationValues);
+      }
+      for (const key of appendSet) {
+        if (!fieldsObj[key]) {
+          continue;
+        }
+        const type = fieldsObj[key].options.type;
+        if (type === "virtual") {
+          appendSet.delete(key);
+          continue;
+        }
+      }
+      let dataBefore = (await repo.findOne({
+        filter: {
+          id: params.filterByTk
+        },
+        appends: [...appendSet]
+      })).toJSON();
+      const lostKeys = getLostKey(dataBefore, params.values);
+      for (const lostKey of lostKeys) {
+        if (lostKey.includes(".") || fieldsObj[lostKey] !== void 0 && ["belongsTo", "belongsToMany", "hasOne", "hasMany"].includes(fieldsObj[lostKey].options.type)) {
+          appendSet.add(lostKey);
+        }
+      }
+      dataBefore = (await repo.findOne({
+        filter: {
+          id: params.filterByTk
+        },
+        appends: [...appendSet]
+      })).toJSON();
+      const changed = getDiffKeyExceptAfter(dataBefore, params.values);
+      return {
+        error: null,
+        data: dataBefore,
+        changed
+      };
+    } catch (err) {
+      ctx.log.error(err);
+      return {
+        error: err.stack
+      };
+    }
+  };
+}
+class WebhookController {
+  async getLink(ctx) {
+    const {
+      params: { name }
+    } = ctx.action;
+    const where = {};
+    if (name) {
+      where["filter"] = {
+        name,
+        type: "code",
+        enabled: true
+      };
+    }
+    if (!name) {
+      throw new Error("not support");
+    }
+    const { currentUser, currentRole } = ctx.state;
+    const { model: UserModel } = ctx.db.getCollection("users");
+    const userInfo = {
+      user: UserModel.build(currentUser).desensitize(),
+      roleName: currentRole
+    };
+    const pluginWorkflow = ctx.app.getPlugin(import__.PluginWorkflow);
+    const repo = ctx.db.getRepository("webhooks");
+    const webhook = await repo.findOne(where);
+    const webhookCtx = {
+      request: ctx.request,
+      action: ctx.action,
+      body: ""
+    };
+    run(webhook.code, {
+      ctx: webhookCtx,
+      lib: {
+        JSON,
+        Math,
+        dayjs: import_utils.dayjs
+      }
+    });
+    if (webhook == null ? void 0 : webhook.workflowKey) {
+      const wfRepo = ctx.db.getRepository("workflows");
+      const wf = await wfRepo.findOne({ filter: { key: webhook.workflowKey, enabled: true } });
+      const processor = await pluginWorkflow.trigger(wf, { data: webhookCtx.body, ...userInfo }, { httpContext: ctx });
+      if (!processor) {
+        return ctx.throw("Workflow should be sync.", 500);
+      }
+      const { lastSavedJob } = processor;
+      if (typeof ctx.body === "undefined") {
+        ctx.withoutDataWrapping = true;
+        ctx.body = lastSavedJob.result;
+      }
+      return;
+    }
+    if (webhookCtx.body) {
+      ctx.withoutDataWrapping = true;
+      ctx.body = webhookCtx.body;
+      return;
+    }
+  }
+  async test(ctx) {
+    const { name, params, body } = ctx.action.params.values;
+    ctx.request.query = params;
+    ctx.action.params = params || {};
+    ctx.action.params.name = name;
+    ctx.action.params.values = body;
+    await new WebhookController().getLink(ctx);
+  }
+  async action(ctx, action) {
+    const webhookCtx = {
+      request: ctx.request,
+      action: ctx.action,
+      body: "",
+      getChanged: getChanged(ctx)
+    };
+    try {
+      await evalSimulate(action.code, {
+        ctx: webhookCtx,
+        lib: {
+          JSON,
+          Math,
+          dayjs: import_utils.dayjs
+        }
+      });
+      return webhookCtx.body;
+    } catch (err) {
+      ctx.app.log.error(err);
+      return null;
+    }
+  }
+  async triggerWorkflow(ctx, action, body) {
+    const { currentUser, currentRole } = ctx.state;
+    const { model: UserModel } = ctx.db.getCollection("users");
+    if (!action.workflowKey) {
+      return;
+    }
+    const userInfo = {
+      user: UserModel.build(currentUser).desensitize(),
+      roleName: currentRole
+    };
+    const pluginWorkflow = ctx.app.getPlugin(import__.PluginWorkflow);
+    const wfRepo = ctx.db.getRepository("workflows");
+    const wf = await wfRepo.findOne({ filter: { key: action.workflowKey, enabled: true } });
+    await pluginWorkflow.trigger(wf, { data: body, ...userInfo }, { httpContext: ctx });
+  }
+}
+function run(jsCode, { ctx, lib }) {
+  try {
+    return new Function("$root", `with($root) { ${jsCode}; }`)({ ctx, lib });
+  } catch (err) {
+    console.log("err", err);
+  }
+}
+async function evalSimulate(jsCode, { ctx, lib }) {
+  const AsyncFunction = async function() {
+  }.constructor;
+  return await new AsyncFunction("$root", `with($root) { ${jsCode}; }`)({
+    ctx,
+    // 允许用户覆盖，这个时候可以使用 _ctx
+    __ctx: ctx,
+    lib
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebhookController
+});

package/dist/server/functions/index.d.ts

@@ -0,0 +1,9 @@
+import Plugin from '..';
+import type { ExecutionModel, FlowNodeModel } from '../types';
+export type CustomFunction = (this: {
+    execution: ExecutionModel;
+    node?: FlowNodeModel;
+}) => any;
+export default function ({ functions }: Plugin, more?: {
+    [key: string]: CustomFunction;
+}): void;

package/dist/server/functions/index.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var functions_exports = {};
+__export(functions_exports, {
+  default: () => functions_default
+});
+module.exports = __toCommonJS(functions_exports);
+function now() {
+  return /* @__PURE__ */ new Date();
+}
+function functions_default({ functions }, more = {}) {
+  functions.register("now", now);
+  for (const [name, fn] of Object.entries(more)) {
+    functions.register(name, fn);
+  }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,8 @@
+export * from './utils';
+export * from './constants';
+export * from './instructions';
+export { Trigger } from './triggers';
+export { default as Processor } from './Processor';
+export { default } from './Plugin';
+export { default as PluginWorkflow } from './Plugin';
+export * from './types';

package/dist/server/index.js

@@ -0,0 +1,54 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  PluginWorkflow: () => import_Plugin2.default,
+  Processor: () => import_Processor.default,
+  Trigger: () => import_triggers.Trigger,
+  default: () => import_Plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./utils"), module.exports);
+__reExport(server_exports, require("./constants"), module.exports);
+__reExport(server_exports, require("./instructions"), module.exports);
+var import_triggers = require("./triggers");
+var import_Processor = __toESM(require("./Processor"));
+var import_Plugin = __toESM(require("./Plugin"));
+var import_Plugin2 = __toESM(require("./Plugin"));
+__reExport(server_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWorkflow,
+  Processor,
+  Trigger,
+  ...require("./utils"),
+  ...require("./constants"),
+  ...require("./instructions"),
+  ...require("./types")
+});

package/dist/server/instructions/CalculationInstruction.d.ts

@@ -0,0 +1,17 @@
+import { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel } from '../types';
+export interface CalculationConfig {
+    engine?: string;
+    expression?: string;
+}
+export declare class CalculationInstruction extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<{
+        result: any;
+        status: 1;
+    } | {
+        result: any;
+        status: -2;
+    }>;
+}
+export default CalculationInstruction;

package/dist/server/instructions/CalculationInstruction.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CalculationInstruction_exports = {};
+__export(CalculationInstruction_exports, {
+  CalculationInstruction: () => CalculationInstruction,
+  default: () => CalculationInstruction_default
+});
+module.exports = __toCommonJS(CalculationInstruction_exports);
+var import_evaluators = require("@tachybase/evaluators");
+var import_lodash = require("lodash");
+var import__ = require(".");
+var import_constants = require("../constants");
+class CalculationInstruction extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    const { engine = "math.js", expression = "", transString = false } = node.config;
+    const scope = processor.getScope(node.id);
+    const evaluator = import_evaluators.evaluators.get(engine);
+    try {
+      let result = evaluator && expression ? evaluator(expression, scope) : null;
+      if (transString && engine === "formula.js") {
+        const context = (0, import_lodash.cloneDeep)(scope);
+        const targetVal = expression.trim().replace(/{{\s*([\w$.-]+)\s*}}/g, (_, v) => {
+          const item = (0, import_lodash.get)(context, v) ?? null;
+          return item;
+        });
+        result = import_evaluators.evaluators.get(engine)(targetVal);
+      }
+      return {
+        result,
+        status: import_constants.JOB_STATUS.RESOLVED
+      };
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: import_constants.JOB_STATUS.ERROR
+      };
+    }
+  }
+}
+var CalculationInstruction_default = CalculationInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CalculationInstruction
+});

package/dist/server/instructions/ConditionInstruction.d.ts

@@ -0,0 +1,29 @@
+import { Registry } from '@tachybase/utils';
+import { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel, JobModel } from '../types';
+type Comparer = (a: any, b: any) => boolean;
+export declare const BRANCH_INDEX: {
+    readonly DEFAULT: any;
+    readonly ON_TRUE: 1;
+    readonly ON_FALSE: 0;
+};
+export declare const calculators: Registry<Comparer>;
+export declare class ConditionInstruction extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<{
+        status: 1;
+        result: boolean;
+        nodeId: number;
+        nodeKey: any;
+        upstreamId: any;
+        cost: number;
+    } | {
+        result: any;
+        status: -2;
+    } | {
+        status: -1;
+        result: boolean;
+    }>;
+    resume(node: FlowNodeModel, branchJob: JobModel, processor: Processor): Promise<any>;
+}
+export default ConditionInstruction;

package/dist/server/instructions/ConditionInstruction.js

@@ -0,0 +1,160 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ConditionInstruction_exports = {};
+__export(ConditionInstruction_exports, {
+  BRANCH_INDEX: () => BRANCH_INDEX,
+  ConditionInstruction: () => ConditionInstruction,
+  calculators: () => calculators,
+  default: () => ConditionInstruction_default
+});
+module.exports = __toCommonJS(ConditionInstruction_exports);
+var import_evaluators = require("@tachybase/evaluators");
+var import_utils = require("@tachybase/utils");
+var import__ = require(".");
+var import_constants = require("../constants");
+const BRANCH_INDEX = {
+  DEFAULT: null,
+  ON_TRUE: 1,
+  ON_FALSE: 0
+};
+const calculators = new import_utils.Registry();
+function equal(a, b) {
+  return a === b;
+}
+function notEqual(a, b) {
+  return a !== b;
+}
+function gt(a, b) {
+  return a > b;
+}
+function gte(a, b) {
+  return a >= b;
+}
+function lt(a, b) {
+  return a < b;
+}
+function lte(a, b) {
+  return a <= b;
+}
+calculators.register("equal", equal);
+calculators.register("notEqual", notEqual);
+calculators.register("gt", gt);
+calculators.register("gte", gte);
+calculators.register("lt", lt);
+calculators.register("lte", lte);
+calculators.register("==", equal);
+calculators.register("!=", notEqual);
+calculators.register(">", gt);
+calculators.register(">=", gte);
+calculators.register("<", lt);
+calculators.register("<=", lte);
+function includes(a, b) {
+  return a.includes(b);
+}
+function notIncludes(a, b) {
+  return !a.includes(b);
+}
+function startsWith(a, b) {
+  return a.startsWith(b);
+}
+function notStartsWith(a, b) {
+  return !a.startsWith(b);
+}
+function endsWith(a, b) {
+  return a.endsWith(b);
+}
+function notEndsWith(a, b) {
+  return !a.endsWith(b);
+}
+calculators.register("includes", includes);
+calculators.register("notIncludes", notIncludes);
+calculators.register("startsWith", startsWith);
+calculators.register("notStartsWith", notStartsWith);
+calculators.register("endsWith", endsWith);
+calculators.register("notEndsWith", notEndsWith);
+function calculate(calculation = {}) {
+  let fn;
+  if (!(calculation.calculator && (fn = calculators.get(calculation.calculator)))) {
+    throw new Error(`no calculator function registered for "${calculation.calculator}"`);
+  }
+  return Boolean(fn(...calculation.operands ?? []));
+}
+function logicCalculate(calculation) {
+  if (!calculation) {
+    return true;
+  }
+  if (typeof calculation["group"] === "object") {
+    const method = calculation["group"].type === "and" ? "every" : "some";
+    return (calculation["group"].calculations ?? [])[method]((item) => logicCalculate(item));
+  }
+  return calculate(calculation);
+}
+class ConditionInstruction extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    const start = prevJob.createdAt || Date.now();
+    const { engine, calculation, expression, rejectOnFalse } = node.config || {};
+    const evaluator = import_evaluators.evaluators.get(engine);
+    let result = true;
+    try {
+      result = evaluator ? evaluator(expression, processor.getScope(node.id)) : logicCalculate(processor.getParsedValue(calculation, node.id));
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: import_constants.JOB_STATUS.ERROR
+      };
+    }
+    if (!result && rejectOnFalse) {
+      return {
+        status: import_constants.JOB_STATUS.FAILED,
+        result
+      };
+    }
+    const job = {
+      status: import_constants.JOB_STATUS.RESOLVED,
+      result,
+      // TODO(optimize): try unify the building of job
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: prevJob && prevJob.id || null,
+      cost: Date.now() - start
+    };
+    const branchNode = processor.nodes.find(
+      (item) => item.upstreamId === node.id && item.branchIndex != null && Boolean(item.branchIndex) === result
+    );
+    if (!branchNode) {
+      return job;
+    }
+    const savedJob = await processor.saveJob(job);
+    await processor.run(branchNode, savedJob);
+    return null;
+  }
+  async resume(node, branchJob, processor) {
+    const job = processor.findBranchParentJob(branchJob, node);
+    if (branchJob.status === import_constants.JOB_STATUS.RESOLVED) {
+      return job;
+    }
+    return processor.exit(branchJob.status);
+  }
+}
+var ConditionInstruction_default = ConditionInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BRANCH_INDEX,
+  ConditionInstruction,
+  calculators
+});

package/dist/server/instructions/CreateInstruction.d.ts

@@ -0,0 +1,10 @@
+import { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel } from '../types';
+export declare class CreateInstruction extends Instruction {
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
+        result: any;
+        status: 1;
+    }>;
+}
+export default CreateInstruction;