@tachybase/module-workflow 0.23.8

package/dist/server/features/notice/actions.js

@@ -0,0 +1,124 @@
+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 actions_exports = {};
+__export(actions_exports, {
+  init: () => init
+});
+module.exports = __toCommonJS(actions_exports);
+var import_actions = __toESM(require("@tachybase/actions"));
+var import__ = require("../..");
+var import_constants = require("../common/constants");
+var import_workflowNotice = require("./collections/workflowNotice");
+var import_constants2 = require("./constants");
+const workflows = {
+  async listWorkflowNoticeFlows(context, next) {
+    context.action.mergeParams({
+      filter: {
+        type: import_constants.NOTICE_INSTRUCTION_NAMESPACE,
+        enabled: true
+      }
+    });
+    return import_actions.default.list(context, next);
+  }
+};
+const workflowNotice = {
+  async listCentralized(context, next) {
+    const centralizedNoticeFlow = await context.db.getRepository(import_workflowNotice.COLLECTION_WORKFLOWS_NAME).find({
+      filter: {
+        "config.centralized": true
+      },
+      fields: ["id"]
+    });
+    context.action.mergeParams({
+      filter: {
+        workflowId: centralizedNoticeFlow.map((item) => item.id)
+      }
+    });
+    return import_actions.default.list(context, next);
+  },
+  async submit(context, next) {
+    const repository = import_actions.utils.getRepositoryFromParams(context);
+    const { filterByTk, values } = context.action.params;
+    const { currentUser } = context.state;
+    if (!currentUser) {
+      return context.throw(401);
+    }
+    const workflowNotice2 = await repository.findOne({
+      filterByTk,
+      filter: {
+        userId: currentUser == null ? void 0 : currentUser.id
+      },
+      appends: ["job", "node", "execution", "workflow"],
+      context
+    });
+    if (!workflowNotice2) {
+      return context.throw(404);
+    }
+    if (!workflowNotice2.workflow.enabled || workflowNotice2.execution.status || workflowNotice2.job.status || workflowNotice2.status !== import_constants2.NOTICE_ACTION_STATUS.PENDING || !(workflowNotice2.node.config.actions ?? []).includes(values.status)) {
+      return context.throw(400);
+    }
+    await workflowNotice2.update({
+      status: values.status
+      //   comment: values.comment,
+      //   snapshot: workflowNotice.approval.data,
+      //   summary: workflowNotice.approval.summary,
+      //   collectionName: workflowNotice.approval.collectionName,
+    });
+    context.body = workflowNotice2.get();
+    context.status = 202;
+    await next();
+    workflowNotice2.execution.workflow = workflowNotice2.workflow;
+    workflowNotice2.job.execution = workflowNotice2.execution;
+    workflowNotice2.job.latestUserJob = workflowNotice2.get();
+    const workflow = context.app.getPlugin(import__.PluginWorkflow);
+    const processor = workflow.createProcessor(workflowNotice2.execution);
+    processor.logger.info(
+      `notice node (${workflowNotice2.nodeId}) action trigger execution (${workflowNotice2.execution.id}) to resume`
+    );
+    workflow.resume(workflowNotice2.job);
+  }
+};
+function init({ app }) {
+  app.actions({
+    ...make(import_workflowNotice.COLLECTION_WORKFLOWS_NAME, workflows),
+    ...make(import_constants.COLLECTION_NOTICE_NAME, workflowNotice)
+  });
+}
+function make(name, mod) {
+  return Object.keys(mod).reduce(
+    (result, key) => ({
+      ...result,
+      [`${name}:${key}`]: mod[key]
+    }),
+    {}
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  init
+});

package/dist/server/features/notice/collections/workflowNotice.d.ts

@@ -0,0 +1,3 @@
+export declare const COLLECTION_WORKFLOWS_NAME = "workflows";
+declare const WorkflowNotice: import("@tachybase/database").CollectionOptions;
+export default WorkflowNotice;

package/dist/server/features/notice/collections/workflowNotice.js

@@ -0,0 +1,90 @@
+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 workflowNotice_exports = {};
+__export(workflowNotice_exports, {
+  COLLECTION_WORKFLOWS_NAME: () => COLLECTION_WORKFLOWS_NAME,
+  default: () => workflowNotice_default
+});
+module.exports = __toCommonJS(workflowNotice_exports);
+var import_database = require("@tachybase/database");
+var import_constants = require("../../common/constants");
+const COLLECTION_WORKFLOWS_NAME = "workflows";
+const WorkflowNotice = (0, import_database.defineCollection)({
+  namespace: "workflow.notice",
+  dumpRules: "required",
+  name: import_constants.COLLECTION_NOTICE_NAME,
+  createdBy: true,
+  updatedBy: true,
+  fields: [
+    {
+      type: "string",
+      name: "collectionName"
+    },
+    {
+      type: "string",
+      name: "dataKey"
+    },
+    {
+      type: "string",
+      name: "index"
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "jsonb",
+      name: "snapshot",
+      defaultValue: {}
+    },
+    {
+      type: "jsonb",
+      name: "summary",
+      defaultValue: {}
+    },
+    {
+      type: "belongsTo",
+      name: "user",
+      target: "users"
+    },
+    {
+      type: "belongsTo",
+      name: "workflow",
+      onDelete: "CASCADE"
+    },
+    {
+      type: "belongsTo",
+      name: "execution"
+    },
+    {
+      type: "belongsTo",
+      name: "node",
+      target: "flow_nodes"
+    },
+    {
+      type: "belongsTo",
+      name: "job",
+      target: "jobs"
+    }
+  ]
+});
+var workflowNotice_default = WorkflowNotice;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COLLECTION_WORKFLOWS_NAME
+});

package/dist/server/features/notice/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const NOTICE_STATUS: {
+    DRAFT: number;
+    RETURNED: number;
+    SUBMITTED: number;
+    PROCESSING: number;
+    APPROVED: number;
+    REJECTED: number;
+};
+export declare const NOTICE_ACTION_STATUS: {
+    ASSIGNED: any;
+    PENDING: number;
+    RETURNED: number;
+    APPROVED: number;
+    REJECTED: number;
+    CANCELED: number;
+};

package/dist/server/features/notice/constants.js

@@ -0,0 +1,44 @@
+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 constants_exports = {};
+__export(constants_exports, {
+  NOTICE_ACTION_STATUS: () => NOTICE_ACTION_STATUS,
+  NOTICE_STATUS: () => NOTICE_STATUS
+});
+module.exports = __toCommonJS(constants_exports);
+const NOTICE_STATUS = {
+  DRAFT: 0,
+  RETURNED: 1,
+  SUBMITTED: 2,
+  PROCESSING: 3,
+  APPROVED: 4,
+  REJECTED: -1
+};
+const NOTICE_ACTION_STATUS = {
+  ASSIGNED: null,
+  PENDING: 0,
+  RETURNED: 1,
+  APPROVED: 2,
+  REJECTED: -1,
+  CANCELED: -2
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NOTICE_ACTION_STATUS,
+  NOTICE_STATUS
+});

package/dist/server/features/notice/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/features/notice/index.js

@@ -0,0 +1,33 @@
+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 notice_exports = {};
+__export(notice_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(notice_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/features/notice/plugin.d.ts

@@ -0,0 +1,12 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginWorkflowNoticeServer extends Plugin {
+    workflow: any;
+    afterAdd(): Promise<void>;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+    install(): Promise<void>;
+    afterEnable(): Promise<void>;
+    afterDisable(): Promise<void>;
+    remove(): Promise<void>;
+}
+export default PluginWorkflowNoticeServer;

package/dist/server/features/notice/plugin.js

@@ -0,0 +1,83 @@
+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 plugin_exports = {};
+__export(plugin_exports, {
+  PluginWorkflowNoticeServer: () => PluginWorkflowNoticeServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_path = __toESM(require("path"));
+var import_server = require("@tachybase/server");
+var import__ = require("../..");
+var import_constants = require("../common/constants");
+var import_actions = require("./actions");
+var import_workflowNotice = require("./collections/workflowNotice");
+var import_NoticeInstruction = __toESM(require("./NoticeInstruction"));
+class PluginWorkflowNoticeServer extends import_server.Plugin {
+  workflow;
+  async afterAdd() {
+  }
+  async beforeLoad() {
+    this.app.on("afterLoadPlugin", (plugin) => {
+      if (!(plugin instanceof import__.PluginWorkflow)) {
+        return;
+      }
+      this.workflow = plugin;
+      plugin.instructions.register(import_constants.NOTICE_INSTRUCTION_NAMESPACE, new import_NoticeInstruction.default(plugin));
+    });
+  }
+  async load() {
+    const { db } = this;
+    db.addMigrations({
+      namespace: import_constants.NOTICE_INSTRUCTION_NAMESPACE,
+      directory: import_path.default.resolve(__dirname, "migrations"),
+      context: {
+        plugin: this
+      }
+    });
+    await db.import({
+      directory: import_path.default.resolve(__dirname, "collections")
+    });
+    (0, import_actions.init)(this);
+    this.app.acl.allow(import_workflowNotice.COLLECTION_WORKFLOWS_NAME, ["listWorkflowNoticeFlows"], "loggedIn");
+    this.app.acl.allow(import_constants.COLLECTION_NOTICE_NAME, ["get", "list", "listCentralized", "submit"], "loggedIn");
+  }
+  async install() {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+}
+var plugin_default = PluginWorkflowNoticeServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWorkflowNoticeServer
+});

package/dist/server/features/notice/tools.d.ts

@@ -0,0 +1,17 @@
+interface ParamsType {
+    summaryConfig: Array<string>;
+    data: object;
+}
+export declare function getSummary(params: ParamsType): object;
+export declare function parsePerson(node: any, processor: any): Promise<unknown[]>;
+export declare const NoticeJobStatusMap: {
+    0: number;
+    1: number;
+    [-5]: number;
+    [-6]: number;
+    [-4]: number;
+};
+export declare function getNegotiationMode(mode: any): {
+    getStatus(distribution: any, assignees: any, mode: any): number;
+};
+export {};

package/dist/server/features/notice/tools.js

@@ -0,0 +1,163 @@
+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 tools_exports = {};
+__export(tools_exports, {
+  NoticeJobStatusMap: () => NoticeJobStatusMap,
+  getNegotiationMode: () => getNegotiationMode,
+  getSummary: () => getSummary,
+  parsePerson: () => parsePerson
+});
+module.exports = __toCommonJS(tools_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_constants = require("../../constants");
+var import_constants2 = require("./constants");
+function getSummary(params) {
+  const { summaryConfig = [], data } = params;
+  const result = summaryConfig.reduce((summary, key) => {
+    const value = import_lodash.default.get(data, key);
+    return {
+      ...summary,
+      [key]: value
+    };
+  }, {});
+  return result;
+}
+async function parsePerson(node, processor) {
+  const configPerson = processor.getParsedValue(node.config.notifiedPerson ?? [], node.id).flat().filter(Boolean);
+  const notifiedPerson = /* @__PURE__ */ new Set();
+  const UserRepo = processor.options.plugin.app.db.getRepository("users");
+  for (const item of configPerson) {
+    if (typeof item === "object") {
+      const result = await UserRepo.find({
+        ...item,
+        fields: ["id"],
+        transaction: processor.transaction
+      });
+      result.forEach((item2) => notifiedPerson.add(item2.id));
+    } else {
+      notifiedPerson.add(item);
+    }
+  }
+  return [...notifiedPerson];
+}
+const NEGOTIATION_MODE = {
+  SINGLE: Symbol("single"),
+  ALL: Symbol("all"),
+  ANY: Symbol("any"),
+  PERCENTAGE: Symbol("percentage")
+};
+const JobStatusMap = {
+  [import_constants2.NOTICE_ACTION_STATUS.PENDING]: import_constants.JOB_STATUS.PENDING,
+  [import_constants2.NOTICE_ACTION_STATUS.APPROVED]: import_constants.JOB_STATUS.RESOLVED,
+  [import_constants2.NOTICE_ACTION_STATUS.REJECTED]: import_constants.JOB_STATUS.REJECTED,
+  [import_constants2.NOTICE_ACTION_STATUS.RETURNED]: import_constants.JOB_STATUS.RETRY_NEEDED
+};
+const Modes = {
+  [NEGOTIATION_MODE.SINGLE]: {
+    getStatus(distribution, assignees, mode) {
+      const done = distribution.find((item) => item.status !== import_constants2.NOTICE_ACTION_STATUS.PENDING && item.count > 0);
+      return done ? JobStatusMap[done.status] : null;
+    }
+  },
+  [NEGOTIATION_MODE.ALL]: {
+    getStatus(distribution, assignees, mode) {
+      const rejected = distribution.find(
+        (item) => [import_constants2.NOTICE_ACTION_STATUS.REJECTED, import_constants2.NOTICE_ACTION_STATUS.RETURNED].includes(item.status)
+      );
+      if (rejected && rejected.count) {
+        return JobStatusMap[rejected.status];
+      }
+      const approved = distribution.find((item) => item.status === import_constants2.NOTICE_ACTION_STATUS.APPROVED);
+      if (approved && approved.count === assignees.length) {
+        return import_constants.JOB_STATUS.RESOLVED;
+      }
+      return null;
+    }
+  },
+  [NEGOTIATION_MODE.ANY]: {
+    getStatus(distribution, assignees, mode) {
+      const returned = distribution.find((item) => item.status === import_constants2.NOTICE_ACTION_STATUS.RETURNED);
+      if (returned && returned.count) {
+        return import_constants.JOB_STATUS.RETRY_NEEDED;
+      }
+      const approved = distribution.find((item) => item.status === import_constants2.NOTICE_ACTION_STATUS.APPROVED);
+      if (approved && approved.count) {
+        return import_constants2.NOTICE_ACTION_STATUS.APPROVED;
+      }
+      const rejectedCount = distribution.reduce(
+        (count, item) => item.status === import_constants2.NOTICE_ACTION_STATUS.REJECTED ? count + item.count : count,
+        0
+      );
+      if (rejectedCount === assignees.length) {
+        return import_constants.JOB_STATUS.REJECTED;
+      }
+      return null;
+    }
+  },
+  [NEGOTIATION_MODE.PERCENTAGE]: {
+    getStatus(distribution, assignees, mode) {
+      const returned = distribution.find((item) => item.status === import_constants2.NOTICE_ACTION_STATUS.RETURNED);
+      if (returned && returned.count) {
+        return import_constants.JOB_STATUS.RETRY_NEEDED;
+      }
+      const approved = distribution.find((item) => item.status === import_constants2.NOTICE_ACTION_STATUS.APPROVED);
+      if (approved && approved.count / assignees.length > mode) {
+        return import_constants.JOB_STATUS.RESOLVED;
+      }
+      const rejected = distribution.find((item) => item.status === import_constants2.NOTICE_ACTION_STATUS.REJECTED);
+      if (rejected && rejected.count / assignees.length >= 1 - mode) {
+        return import_constants.JOB_STATUS.REJECTED;
+      }
+      return null;
+    }
+  }
+};
+const NoticeJobStatusMap = {
+  [import_constants.JOB_STATUS.PENDING]: import_constants2.NOTICE_ACTION_STATUS.PENDING,
+  [import_constants.JOB_STATUS.RESOLVED]: import_constants2.NOTICE_ACTION_STATUS.APPROVED,
+  [import_constants.JOB_STATUS.REJECTED]: import_constants2.NOTICE_ACTION_STATUS.REJECTED,
+  [import_constants.JOB_STATUS.RETRY_NEEDED]: import_constants2.NOTICE_ACTION_STATUS.RETURNED,
+  [import_constants.JOB_STATUS.CANCELED]: import_constants2.NOTICE_ACTION_STATUS.CANCELED
+};
+function getNegotiationMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[NEGOTIATION_MODE.ALL];
+    case (0 < mode && mode < 1):
+      return Modes[NEGOTIATION_MODE.PERCENTAGE];
+    default:
+      return Modes[NEGOTIATION_MODE.SINGLE];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoticeJobStatusMap,
+  getNegotiationMode,
+  getSummary,
+  parsePerson
+});

package/dist/server/features/omni-trigger/CustomActionTrigger.d.ts

@@ -0,0 +1,11 @@
+import { Context, Next } from '@tachybase/actions';
+import Trigger from '../../triggers';
+export declare class OmniTrigger extends Trigger {
+    static TYPE: string;
+    constructor(workflow: any);
+    triggerAction: (context: any, next: any) => Promise<any>;
+    middleware: (context: Context, next: Next) => Promise<any>;
+    private trigger;
+    on(): void;
+    off(): void;
+}