chatbot-lex-design-builder 2.0.25 → 2.0.27

package/dist/cjs/index.d.ts

@@ -11,4 +11,5 @@ import { isAgentTransferPresent } from "./utils/is-agent-transfer-exists";
 import * as NodeBuildersModule from "./utils/node-builders";
 import { removeAgentTransfer } from "./utils/remove-agent-transfer";
 import * as AgenticModule from "./agentic/sdk";
-export { addAgentTransfer, EdgesModule, exportToZip, getIntents, GraphModule, isAgentTransferPresent, NodeBuildersModule, NodesModule, OthersModule, removeAgentTransfer, ResponsesModule, UtilsModule, AgenticModule };
+import * as AgenticNodeModules from "./workflows/lib/index";
+export { addAgentTransfer, EdgesModule, exportToZip, getIntents, GraphModule, isAgentTransferPresent, NodeBuildersModule, NodesModule, OthersModule, removeAgentTransfer, ResponsesModule, UtilsModule, AgenticModule, AgenticNodeModules };

package/dist/cjs/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgenticModule = exports.UtilsModule = exports.ResponsesModule = exports.removeAgentTransfer = exports.OthersModule = exports.NodesModule = exports.NodeBuildersModule = exports.isAgentTransferPresent = exports.GraphModule = exports.getIntents = exports.exportToZip = exports.EdgesModule = exports.addAgentTransfer = void 0;
+exports.AgenticNodeModules = exports.AgenticModule = exports.UtilsModule = exports.ResponsesModule = exports.removeAgentTransfer = exports.OthersModule = exports.NodesModule = exports.NodeBuildersModule = exports.isAgentTransferPresent = exports.GraphModule = exports.getIntents = exports.exportToZip = exports.EdgesModule = exports.addAgentTransfer = void 0;
 const export_to_zip_1 = require("./export-to-zip");
 Object.defineProperty(exports, "exportToZip", { enumerable: true, get: function () { return export_to_zip_1.exportToZip; } });
 const get_intent_nodes_1 = require("./get-intent-nodes");
@@ -50,4 +50,6 @@ const remove_agent_transfer_1 = require("./utils/remove-agent-transfer");
 Object.defineProperty(exports, "removeAgentTransfer", { enumerable: true, get: function () { return remove_agent_transfer_1.removeAgentTransfer; } });
 const AgenticModule = __importStar(require("./agentic/sdk"));
 exports.AgenticModule = AgenticModule;
+const AgenticNodeModules = __importStar(require("./workflows/lib/index"));
+exports.AgenticNodeModules = AgenticNodeModules;
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mDAA8C;AAoB5C,4FApBO,2BAAW,OAoBP;AAnBb,yDAAgD;AAoB9C,2FApBO,6BAAU,OAoBP;AAlBZ,2DAA6C;AAgB3C,kCAAW;AAfb,2DAA6C;AAkB3C,kCAAW;AAjBb,2DAA6C;AAoB3C,kCAAW;AAlBb,6DAA+C;AAmB7C,oCAAY;AAlBd,mEAAqD;AAoBnD,0CAAe;AAnBjB,qDAAuC;AAoBrC,kCAAW;AAnBb,mEAA8D;AAQ5D,iGARO,qCAAgB,OAQP;AAPlB,+EAA0E;AAYxE,uGAZO,iDAAsB,OAYP;AAXxB,0EAA4D;AAY1D,gDAAkB;AAXpB,yEAAoE;AAclE,oGAdO,2CAAmB,OAcP;AAbrB,6DAA+C;AAgB7C,sCAAa"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mDAA8C;AAqB5C,4FArBO,2BAAW,OAqBP;AApBb,yDAAgD;AAqB9C,2FArBO,6BAAU,OAqBP;AAnBZ,2DAA6C;AAiB3C,kCAAW;AAhBb,2DAA6C;AAmB3C,kCAAW;AAlBb,2DAA6C;AAqB3C,kCAAW;AAnBb,6DAA+C;AAoB7C,oCAAY;AAnBd,mEAAqD;AAqBnD,0CAAe;AApBjB,qDAAuC;AAqBrC,kCAAW;AApBb,mEAA8D;AAS5D,iGATO,qCAAgB,OASP;AARlB,+EAA0E;AAaxE,uGAbO,iDAAsB,OAaP;AAZxB,0EAA4D;AAa1D,gDAAkB;AAZpB,yEAAoE;AAelE,oGAfO,2CAAmB,OAeP;AAdrB,6DAA+C;AAiB7C,sCAAa;AAhBf,0EAA4D;AAiB1D,gDAAkB"}

package/dist/cjs/workflows/lib/index.d.ts

@@ -0,0 +1 @@
+export * as AgenticNodeModules from "./nodes";

package/dist/cjs/workflows/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgenticNodeModules = void 0;
+exports.AgenticNodeModules = __importStar(require("./nodes"));
+//# sourceMappingURL=index.js.map

package/dist/cjs/workflows/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../workflows/lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8DAA8C"}

package/dist/cjs/workflows/lib/nodes/agent-node.d.ts

@@ -0,0 +1,71 @@
+import z from "zod";
+import { NodeType } from "./node-type";
+export declare const AgentDataSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        expression: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            LoopCondition: "LoopCondition";
+            ReturnValueToLoopStart: "ReturnValueToLoopStart";
+            ExitLoop: "ExitLoop";
+        }>>>>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    outputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    name: z.ZodString;
+    agentAliasArn: z.ZodString;
+}, z.core.$strip>;
+export type AgentData = z.infer<typeof AgentDataSchema>;
+export declare const AgentNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeType.agentNode>;
+    data: z.ZodObject<{
+        inputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            expression: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+                LoopCondition: "LoopCondition";
+                ReturnValueToLoopStart: "ReturnValueToLoopStart";
+                ExitLoop: "ExitLoop";
+            }>>>>;
+            enabled: z.ZodCatch<z.ZodBoolean>;
+        }, z.core.$strip>>>>>;
+        outputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            enabled: z.ZodCatch<z.ZodBoolean>;
+        }, z.core.$strip>>>>>;
+        name: z.ZodString;
+        agentAliasArn: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AgentNode = z.infer<typeof AgentNodeSchema>;

package/dist/cjs/workflows/lib/nodes/agent-node.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentNodeSchema = exports.AgentDataSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const node_type_1 = require("./node-type");
+const base_node_1 = require("./base-node");
+exports.AgentDataSchema = base_node_1.BaseNodeSchema.extend({
+    agentAliasArn: zod_1.default.string().trim().max(2048),
+});
+exports.AgentNodeSchema = zod_1.default.object({
+    type: zod_1.default.literal(node_type_1.NodeType.agentNode),
+    data: exports.AgentDataSchema,
+});
+//# sourceMappingURL=agent-node.js.map

package/dist/cjs/workflows/lib/nodes/agent-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-node.js","sourceRoot":"","sources":["../../../../../workflows/lib/nodes/agent-node.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AACpB,2CAAuC;AACvC,2CAA6C;AAChC,QAAA,eAAe,GAAG,0BAAc,CAAC,MAAM,CAAC;IACnD,aAAa,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;CAC3C,CAAC,CAAC;AAGU,QAAA,eAAe,GAAG,aAAC,CAAC,MAAM,CAAC;IACtC,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,oBAAQ,CAAC,SAAS,CAAC;IACnC,IAAI,EAAE,uBAAe;CACtB,CAAC,CAAC"}

package/dist/cjs/workflows/lib/nodes/base-node.d.ts

@@ -0,0 +1,33 @@
+import z from "zod";
+export declare const BaseNodeSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        expression: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            LoopCondition: "LoopCondition";
+            ReturnValueToLoopStart: "ReturnValueToLoopStart";
+            ExitLoop: "ExitLoop";
+        }>>>>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    outputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type BaseNodeData = z.infer<typeof BaseNodeSchema>;

package/dist/cjs/workflows/lib/nodes/base-node.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNodeSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const flow_output_type_1 = require("./flow-output-type");
+const flow_input_type_1 = require("./flow-input-type");
+exports.BaseNodeSchema = zod_1.default.object({
+    inputs: flow_input_type_1.FlowInputTypeSchema.array().max(20).optional().nullish(),
+    outputs: flow_output_type_1.FlowOutputTypeSchema.array().max(5).optional().nullish(),
+    name: zod_1.default.string().trim(),
+});
+//# sourceMappingURL=base-node.js.map

package/dist/cjs/workflows/lib/nodes/base-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-node.js","sourceRoot":"","sources":["../../../../../workflows/lib/nodes/base-node.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AACpB,yDAA0D;AAC1D,uDAAwD;AAE3C,QAAA,cAAc,GAAG,aAAC,CAAC,MAAM,CAAC;IACrC,MAAM,EAAE,qCAAmB,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE;IAChE,OAAO,EAAE,uCAAoB,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE;IACjE,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE;CACxB,CAAC,CAAC"}

package/dist/cjs/workflows/lib/nodes/category-type.d.ts

@@ -0,0 +1,7 @@
+import z from "zod";
+export declare const CategoryTypeSchema: z.ZodEnum<{
+    LoopCondition: "LoopCondition";
+    ReturnValueToLoopStart: "ReturnValueToLoopStart";
+    ExitLoop: "ExitLoop";
+}>;
+export type CategoryType = z.infer<typeof CategoryTypeSchema>;

package/dist/cjs/workflows/lib/nodes/category-type.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryTypeSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.CategoryTypeSchema = zod_1.default.enum([
+    "LoopCondition",
+    "ReturnValueToLoopStart",
+    "ExitLoop",
+]);
+//# sourceMappingURL=category-type.js.map

package/dist/cjs/workflows/lib/nodes/category-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"category-type.js","sourceRoot":"","sources":["../../../../../workflows/lib/nodes/category-type.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AAEP,QAAA,kBAAkB,GAAG,aAAC,CAAC,IAAI,CAAC;IACvC,eAAe;IACf,wBAAwB;IACxB,UAAU;CACX,CAAC,CAAC"}

package/dist/cjs/workflows/lib/nodes/collector-node.d.ts

@@ -0,0 +1,69 @@
+import z from "zod";
+import { NodeType } from "./node-type";
+export declare const CollectorDataSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        expression: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            LoopCondition: "LoopCondition";
+            ReturnValueToLoopStart: "ReturnValueToLoopStart";
+            ExitLoop: "ExitLoop";
+        }>>>>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    outputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type CollectorData = z.infer<typeof CollectorDataSchema>;
+export declare const CollectorNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeType.collectorNode>;
+    data: z.ZodObject<{
+        inputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            expression: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+                LoopCondition: "LoopCondition";
+                ReturnValueToLoopStart: "ReturnValueToLoopStart";
+                ExitLoop: "ExitLoop";
+            }>>>>;
+            enabled: z.ZodCatch<z.ZodBoolean>;
+        }, z.core.$strip>>>>>;
+        outputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            enabled: z.ZodCatch<z.ZodBoolean>;
+        }, z.core.$strip>>>>>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CollectorNode = z.infer<typeof CollectorNodeSchema>;

package/dist/cjs/workflows/lib/nodes/collector-node.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectorNodeSchema = exports.CollectorDataSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const node_type_1 = require("./node-type");
+const base_node_1 = require("./base-node");
+exports.CollectorDataSchema = base_node_1.BaseNodeSchema.extend({});
+exports.CollectorNodeSchema = zod_1.default.object({
+    type: zod_1.default.literal(node_type_1.NodeType.collectorNode),
+    data: exports.CollectorDataSchema,
+});
+//# sourceMappingURL=collector-node.js.map

package/dist/cjs/workflows/lib/nodes/collector-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector-node.js","sourceRoot":"","sources":["../../../../../workflows/lib/nodes/collector-node.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AACpB,2CAAuC;AACvC,2CAA6C;AAChC,QAAA,mBAAmB,GAAG,0BAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAGhD,QAAA,mBAAmB,GAAG,aAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,oBAAQ,CAAC,aAAa,CAAC;IACvC,IAAI,EAAE,2BAAmB;CAC1B,CAAC,CAAC"}

package/dist/cjs/workflows/lib/nodes/condition-node.d.ts

@@ -0,0 +1,83 @@
+import z from "zod";
+import { NodeType } from "./node-type";
+declare const ConditionSchema: z.ZodObject<{
+    name: z.ZodString;
+    expression: z.ZodString;
+}, z.core.$strip>;
+export type Condition = z.infer<typeof ConditionSchema>;
+export declare const ConditionDataSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        expression: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            LoopCondition: "LoopCondition";
+            ReturnValueToLoopStart: "ReturnValueToLoopStart";
+            ExitLoop: "ExitLoop";
+        }>>>>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    outputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        enabled: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>>>;
+    name: z.ZodString;
+    conditions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        expression: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ConditionData = z.infer<typeof ConditionDataSchema>;
+export declare const ConditionNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeType.conditionNode>;
+    data: z.ZodObject<{
+        inputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            expression: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+                LoopCondition: "LoopCondition";
+                ReturnValueToLoopStart: "ReturnValueToLoopStart";
+                ExitLoop: "ExitLoop";
+            }>>>>;
+            enabled: z.ZodCatch<z.ZodBoolean>;
+        }, z.core.$strip>>>>>;
+        outputs: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            enabled: z.ZodCatch<z.ZodBoolean>;
+        }, z.core.$strip>>>>>;
+        name: z.ZodString;
+        conditions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ConditionNode = z.infer<typeof ConditionNodeSchema>;
+export {};

package/dist/cjs/workflows/lib/nodes/condition-node.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionNodeSchema = exports.ConditionDataSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const node_type_1 = require("./node-type");
+const base_node_1 = require("./base-node");
+const ConditionSchema = zod_1.default.object({
+    name: zod_1.default.string().trim().nonempty(),
+    expression: zod_1.default.string().trim().nonempty().max(64),
+});
+exports.ConditionDataSchema = base_node_1.BaseNodeSchema.extend({
+    conditions: ConditionSchema.array().min(1).max(5),
+});
+exports.ConditionNodeSchema = zod_1.default.object({
+    type: zod_1.default.literal(node_type_1.NodeType.conditionNode),
+    data: exports.ConditionDataSchema,
+});
+//# sourceMappingURL=condition-node.js.map

package/dist/cjs/workflows/lib/nodes/condition-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-node.js","sourceRoot":"","sources":["../../../../../workflows/lib/nodes/condition-node.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AACpB,2CAAuC;AACvC,2CAA6C;AAE7C,MAAM,eAAe,GAAG,aAAC,CAAC,MAAM,CAAC;IAC/B,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;IAClC,UAAU,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;CACjD,CAAC,CAAC;AAIU,QAAA,mBAAmB,GAAG,0BAAc,CAAC,MAAM,CAAC;IACvD,UAAU,EAAE,eAAe,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CAClD,CAAC,CAAC;AAGU,QAAA,mBAAmB,GAAG,aAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,oBAAQ,CAAC,aAAa,CAAC;IACvC,IAAI,EAAE,2BAAmB;CAC1B,CAAC,CAAC"}

package/dist/cjs/workflows/lib/nodes/data-type.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+export declare const DataTypeSchema: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    object: "object";
+    array: "array";
+}>;
+export type DataType = z.infer<typeof DataTypeSchema>;

package/dist/cjs/workflows/lib/nodes/data-type.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTypeSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.DataTypeSchema = zod_1.default.enum(["string", "number", "boolean", "object", "array"]);
+//# sourceMappingURL=data-type.js.map

package/dist/cjs/workflows/lib/nodes/data-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type.js","sourceRoot":"","sources":["../../../../../workflows/lib/nodes/data-type.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AAEP,QAAA,cAAc,GAAG,aAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAC,QAAQ,EAAC,SAAS,EAAC,QAAQ,EAAC,OAAO,CAAC,CAAC,CAAA"}