@elqnt/workflow 1.0.0

package/dist/index.mjs

@@ -0,0 +1,4808 @@
+// components/dynamic-schema-form.tsx
+import { useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function DynamicSchemaForm({
+  schema,
+  value = {},
+  onChange,
+  disabled = false,
+  path = [],
+  components,
+  variables = [],
+  showVariablePicker = false
+}) {
+  const [collapsedSections, setCollapsedSections] = useState(
+    /* @__PURE__ */ new Set()
+  );
+  const [openVariablePickers, setOpenVariablePickers] = useState(
+    /* @__PURE__ */ new Set()
+  );
+  const [openRichTextDialogs, setOpenRichTextDialogs] = useState(
+    /* @__PURE__ */ new Set()
+  );
+  const [richTextDraftValues, setRichTextDraftValues] = useState({});
+  const {
+    Input,
+    Label,
+    Textarea,
+    Checkbox,
+    Select,
+    SelectTrigger,
+    SelectValue,
+    SelectContent,
+    SelectItem,
+    Button,
+    Card,
+    PlusIcon,
+    TrashIcon,
+    ChevronDownIcon,
+    ChevronRightIcon,
+    VariableIcon,
+    CheckIcon,
+    EditIcon,
+    Popover,
+    PopoverTrigger,
+    PopoverContent,
+    Dialog,
+    DialogContent,
+    DialogHeader,
+    DialogTitle,
+    DialogFooter,
+    ScrollArea,
+    MarkdownEditor,
+    cn
+  } = components;
+  const isVariableReference = (val) => {
+    return typeof val === "string" && val.startsWith("{{") && val.endsWith("}}");
+  };
+  const getMatchingVariables = (fieldType) => {
+    if (!fieldType) return variables;
+    const compatibleTypes = {
+      string: ["string"],
+      number: ["number", "integer"],
+      integer: ["number", "integer"],
+      boolean: ["boolean"],
+      object: ["object"],
+      array: ["array"]
+    };
+    const compatible = compatibleTypes[fieldType] || [fieldType];
+    return variables.filter((v) => compatible.includes(v.type));
+  };
+  const toggleVariablePicker = (fieldPath) => {
+    setOpenVariablePickers((prev) => {
+      const next = new Set(prev);
+      if (next.has(fieldPath)) {
+        next.delete(fieldPath);
+      } else {
+        next.add(fieldPath);
+      }
+      return next;
+    });
+  };
+  const renderVariablePicker = (fieldName, fieldType, fieldPath, onSelect) => {
+    if (!showVariablePicker) {
+      return null;
+    }
+    if (!VariableIcon || !Popover || !PopoverTrigger || !PopoverContent) {
+      return null;
+    }
+    const matchingVars = getMatchingVariables(fieldType);
+    const isOpen = openVariablePickers.has(fieldPath);
+    const currentValue = value[fieldName];
+    const isVariable = isVariableReference(currentValue);
+    return /* @__PURE__ */ jsxs(
+      Popover,
+      {
+        open: isOpen,
+        onOpenChange: (open) => {
+          if (open) {
+            setOpenVariablePickers((prev) => new Set(prev).add(fieldPath));
+          } else {
+            setOpenVariablePickers((prev) => {
+              const next = new Set(prev);
+              next.delete(fieldPath);
+              return next;
+            });
+          }
+        },
+        children: [
+          /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              className: cn(
+                "h-8 px-2 shrink-0",
+                isVariable && "border-primary text-primary"
+              ),
+              disabled,
+              children: /* @__PURE__ */ jsx(VariableIcon, { className: "h-3.5 w-3.5" })
+            }
+          ) }),
+          /* @__PURE__ */ jsxs(PopoverContent, { className: "w-56 p-1", align: "end", children: [
+            /* @__PURE__ */ jsxs("div", { className: "text-xs font-medium text-muted-foreground px-2 py-1.5", children: [
+              "Select Variable (",
+              fieldType || "any",
+              ")"
+            ] }),
+            /* @__PURE__ */ jsx("div", { className: "max-h-48 overflow-y-auto", children: matchingVars.length === 0 ? /* @__PURE__ */ jsxs("div", { className: "px-2 py-3 text-xs text-muted-foreground text-center", children: [
+              "No variables available.",
+              /* @__PURE__ */ jsx("br", {}),
+              /* @__PURE__ */ jsx("span", { className: "text-[10px]", children: "Add variables in Workflow Settings \u2192 Variables" })
+            ] }) : matchingVars.map((variable) => {
+              const varRef = `{{${variable.path}}}`;
+              const isSelected = currentValue === varRef;
+              return /* @__PURE__ */ jsxs(
+                "button",
+                {
+                  type: "button",
+                  className: cn(
+                    "w-full text-left px-2 py-1.5 text-xs rounded hover:bg-accent flex items-center justify-between",
+                    isSelected && "bg-accent"
+                  ),
+                  onClick: () => {
+                    onSelect(varRef);
+                    setOpenVariablePickers((prev) => {
+                      const next = new Set(prev);
+                      next.delete(fieldPath);
+                      return next;
+                    });
+                  },
+                  children: [
+                    /* @__PURE__ */ jsxs("div", { children: [
+                      /* @__PURE__ */ jsx("div", { className: "font-medium", children: variable.title || variable.name }),
+                      /* @__PURE__ */ jsx("div", { className: "text-[10px] text-muted-foreground font-mono", children: variable.path })
+                    ] }),
+                    isSelected && CheckIcon && /* @__PURE__ */ jsx(CheckIcon, { className: "h-3 w-3" })
+                  ]
+                },
+                variable.path
+              );
+            }) })
+          ] })
+        ]
+      }
+    );
+  };
+  const toggleSection = (key) => {
+    setCollapsedSections((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) {
+        next.delete(key);
+      } else {
+        next.add(key);
+      }
+      return next;
+    });
+  };
+  const handleFieldChange = (fieldName, fieldValue) => {
+    onChange({
+      ...value,
+      [fieldName]: fieldValue
+    });
+  };
+  const renderField = (fieldSchema, fieldName, fieldValue) => {
+    const fieldPath = [...path, fieldName].join(".");
+    const isRequired = schema.required?.includes(fieldName);
+    if (fieldSchema.enum) {
+      const labels = fieldSchema["x-enumLabels"] || fieldSchema.enum;
+      return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+          fieldSchema.title || fieldName,
+          isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+        ] }),
+        /* @__PURE__ */ jsxs(
+          Select,
+          {
+            value: fieldValue || "",
+            onValueChange: (v) => handleFieldChange(fieldName, v),
+            disabled,
+            children: [
+              /* @__PURE__ */ jsx(SelectTrigger, { className: "h-8 text-xs", children: /* @__PURE__ */ jsx(
+                SelectValue,
+                {
+                  placeholder: `Select ${fieldSchema.title || fieldName}`
+                }
+              ) }),
+              /* @__PURE__ */ jsx(SelectContent, { children: fieldSchema.enum.map((option, idx) => /* @__PURE__ */ jsx(SelectItem, { value: option, className: "text-xs", children: labels[idx] || option }, option)) })
+            ]
+          }
+        ),
+        fieldSchema.description && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-muted-foreground", children: fieldSchema.description })
+      ] }, fieldPath);
+    }
+    if (fieldSchema.type === "object" && fieldSchema.properties) {
+      const isCollapsed = collapsedSections.has(fieldPath);
+      return /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => toggleSection(fieldPath),
+            className: "flex items-center gap-1 text-xs font-medium text-gray-700 hover:text-gray-900",
+            children: [
+              isCollapsed ? /* @__PURE__ */ jsx(ChevronRightIcon, { className: "h-3 w-3" }) : /* @__PURE__ */ jsx(ChevronDownIcon, { className: "h-3 w-3" }),
+              fieldSchema.title || fieldName
+            ]
+          }
+        ),
+        !isCollapsed && /* @__PURE__ */ jsx(Card, { className: "p-3 bg-gray-50/50", children: /* @__PURE__ */ jsx(
+          DynamicSchemaForm,
+          {
+            schema: fieldSchema,
+            value: fieldValue || {},
+            onChange: (v) => handleFieldChange(fieldName, v),
+            disabled,
+            path: [...path, fieldName],
+            components,
+            variables,
+            showVariablePicker
+          }
+        ) })
+      ] }, fieldPath);
+    }
+    if (fieldSchema.type === "array" && fieldSchema.items) {
+      const arrayValue = Array.isArray(fieldValue) ? fieldValue : [];
+      const itemSchema = fieldSchema.items;
+      return /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+            fieldSchema.title || fieldName,
+            isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+          ] }),
+          /* @__PURE__ */ jsxs(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              className: "h-6 text-xs px-2",
+              onClick: () => {
+                const newItem = itemSchema.type === "object" ? {} : "";
+                handleFieldChange(fieldName, [...arrayValue, newItem]);
+              },
+              disabled,
+              children: [
+                /* @__PURE__ */ jsx(PlusIcon, { className: "h-3 w-3 mr-1" }),
+                "Add"
+              ]
+            }
+          )
+        ] }),
+        fieldSchema.description && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-muted-foreground", children: fieldSchema.description }),
+        /* @__PURE__ */ jsx("div", { className: "space-y-2", children: arrayValue.map((item, index) => /* @__PURE__ */ jsxs("div", { className: "flex gap-2 items-start", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex-1", children: itemSchema.type === "object" ? /* @__PURE__ */ jsx(Card, { className: "p-2 bg-gray-50/50", children: /* @__PURE__ */ jsx(
+            DynamicSchemaForm,
+            {
+              schema: itemSchema,
+              value: item,
+              onChange: (v) => {
+                const newArray = [...arrayValue];
+                newArray[index] = v;
+                handleFieldChange(fieldName, newArray);
+              },
+              disabled,
+              path: [...path, fieldName, String(index)],
+              components,
+              variables,
+              showVariablePicker
+            }
+          ) }) : /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: item || "",
+              onChange: (e) => {
+                const newArray = [...arrayValue];
+                newArray[index] = e.target.value;
+                handleFieldChange(fieldName, newArray);
+              },
+              disabled,
+              className: "h-8 text-xs"
+            }
+          ) }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "ghost",
+              size: "sm",
+              className: "h-8 w-8 p-0 text-red-500 hover:text-red-700",
+              onClick: () => {
+                const newArray = arrayValue.filter(
+                  (_, i) => i !== index
+                );
+                handleFieldChange(fieldName, newArray);
+              },
+              disabled,
+              children: /* @__PURE__ */ jsx(TrashIcon, { className: "h-3 w-3" })
+            }
+          )
+        ] }, index)) })
+      ] }, fieldPath);
+    }
+    if (fieldSchema.type === "boolean") {
+      return /* @__PURE__ */ jsxs("div", { className: "flex items-center space-x-2", children: [
+        /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            id: fieldPath,
+            checked: !!fieldValue,
+            onCheckedChange: (checked) => handleFieldChange(fieldName, checked),
+            disabled
+          }
+        ),
+        /* @__PURE__ */ jsxs(Label, { htmlFor: fieldPath, className: "text-xs font-normal", children: [
+          fieldSchema.title || fieldName,
+          isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+        ] }),
+        fieldSchema.description && /* @__PURE__ */ jsxs("span", { className: "text-[10px] text-muted-foreground ml-2", children: [
+          "(",
+          fieldSchema.description,
+          ")"
+        ] })
+      ] }, fieldPath);
+    }
+    if (fieldSchema.type === "number" || fieldSchema.type === "integer") {
+      const isVarValue = isVariableReference(fieldValue);
+      return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+          fieldSchema.title || fieldName,
+          isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex gap-1.5", children: [
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              type: isVarValue ? "text" : "number",
+              value: fieldValue ?? "",
+              onChange: (e) => {
+                if (isVariableReference(e.target.value)) {
+                  handleFieldChange(fieldName, e.target.value);
+                } else {
+                  const val = e.target.value === "" ? void 0 : Number(e.target.value);
+                  handleFieldChange(fieldName, val);
+                }
+              },
+              min: fieldSchema.minimum,
+              max: fieldSchema.maximum,
+              step: fieldSchema.type === "integer" ? 1 : "any",
+              disabled,
+              className: cn("h-8 text-xs flex-1", isVarValue && "font-mono text-primary")
+            }
+          ),
+          renderVariablePicker(
+            fieldName,
+            fieldSchema.type,
+            fieldPath,
+            (varPath) => handleFieldChange(fieldName, varPath)
+          )
+        ] }),
+        fieldSchema.description && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-muted-foreground", children: fieldSchema.description })
+      ] }, fieldPath);
+    }
+    if (fieldSchema.type === "string") {
+      if (fieldSchema.format === "richtext") {
+        const isDialogOpen = openRichTextDialogs.has(fieldPath);
+        const draftValue = richTextDraftValues[fieldPath] ?? fieldValue ?? "";
+        const previewText = (fieldValue || "").replace(/<[^>]*>/g, "").slice(0, 50);
+        const matchingVars = getMatchingVariables("string");
+        if (!Dialog || !DialogContent || !DialogHeader || !DialogTitle || !DialogFooter) {
+          return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+              /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+                fieldSchema.title || fieldName,
+                isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+              ] }),
+              renderVariablePicker(
+                fieldName,
+                "string",
+                fieldPath,
+                (varPath) => handleFieldChange(fieldName, (fieldValue || "") + varPath)
+              )
+            ] }),
+            /* @__PURE__ */ jsx(
+              Textarea,
+              {
+                value: fieldValue || "",
+                onChange: (e) => handleFieldChange(fieldName, e.target.value),
+                disabled,
+                rows: 3,
+                className: "text-xs",
+                placeholder: fieldSchema.description
+              }
+            )
+          ] }, fieldPath);
+        }
+        return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+          /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+            fieldSchema.title || fieldName,
+            isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-1.5", children: [
+            /* @__PURE__ */ jsx("div", { className: "flex-1 min-w-0 px-2 py-1.5 bg-muted/50 rounded text-xs text-muted-foreground truncate border", children: previewText || /* @__PURE__ */ jsx("span", { className: "italic", children: "Click edit to add content..." }) }),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                type: "button",
+                variant: "outline",
+                size: "sm",
+                className: "h-8 px-2 shrink-0",
+                onClick: () => {
+                  setRichTextDraftValues((prev) => ({ ...prev, [fieldPath]: fieldValue || "" }));
+                  setOpenRichTextDialogs((prev) => new Set(prev).add(fieldPath));
+                },
+                disabled,
+                children: EditIcon ? /* @__PURE__ */ jsx(EditIcon, { className: "h-3.5 w-3.5" }) : "Edit"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            Dialog,
+            {
+              open: isDialogOpen,
+              onOpenChange: (open) => {
+                if (!open) {
+                  setOpenRichTextDialogs((prev) => {
+                    const next = new Set(prev);
+                    next.delete(fieldPath);
+                    return next;
+                  });
+                }
+              },
+              children: /* @__PURE__ */ jsxs(DialogContent, { className: "max-w-3xl max-h-[85vh] flex flex-col", children: [
+                /* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsxs(DialogTitle, { children: [
+                  "Edit ",
+                  fieldSchema.title || fieldName
+                ] }) }),
+                /* @__PURE__ */ jsx("div", { className: "flex-1 overflow-hidden flex flex-col min-h-0", children: MarkdownEditor ? /* @__PURE__ */ jsx(
+                  MarkdownEditor,
+                  {
+                    content: draftValue,
+                    onChange: (value2) => {
+                      setRichTextDraftValues((prev) => ({ ...prev, [fieldPath]: value2 }));
+                    },
+                    placeholder: "Enter content... Use {{variables.name}} for dynamic values",
+                    minHeight: "300px",
+                    variables: showVariablePicker ? matchingVars : []
+                  }
+                ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                  /* @__PURE__ */ jsx(
+                    Textarea,
+                    {
+                      value: draftValue,
+                      onChange: (e) => {
+                        setRichTextDraftValues((prev) => ({ ...prev, [fieldPath]: e.target.value }));
+                      },
+                      rows: 12,
+                      className: "flex-1 text-sm font-mono resize-none",
+                      placeholder: "Enter content... Use {{variables.name}} for dynamic values"
+                    }
+                  ),
+                  showVariablePicker && matchingVars.length > 0 && /* @__PURE__ */ jsxs("div", { className: "border rounded-md p-2 bg-muted/30 mt-3", children: [
+                    /* @__PURE__ */ jsx("p", { className: "text-xs font-medium mb-2", children: "Insert Variable:" }),
+                    /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-1", children: matchingVars.map((variable) => /* @__PURE__ */ jsx(
+                      Button,
+                      {
+                        type: "button",
+                        variant: "outline",
+                        size: "sm",
+                        className: "h-6 text-xs px-2",
+                        onClick: () => {
+                          const varRef = `{{${variable.path}}}`;
+                          setRichTextDraftValues((prev) => ({
+                            ...prev,
+                            [fieldPath]: (prev[fieldPath] || "") + varRef
+                          }));
+                        },
+                        children: variable.title || variable.name
+                      },
+                      variable.path
+                    )) })
+                  ] })
+                ] }) }),
+                /* @__PURE__ */ jsxs(DialogFooter, { children: [
+                  /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      type: "button",
+                      variant: "outline",
+                      onClick: () => {
+                        setOpenRichTextDialogs((prev) => {
+                          const next = new Set(prev);
+                          next.delete(fieldPath);
+                          return next;
+                        });
+                      },
+                      children: "Cancel"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      type: "button",
+                      onClick: () => {
+                        handleFieldChange(fieldName, draftValue);
+                        setOpenRichTextDialogs((prev) => {
+                          const next = new Set(prev);
+                          next.delete(fieldPath);
+                          return next;
+                        });
+                      },
+                      children: "Save"
+                    }
+                  )
+                ] })
+              ] })
+            }
+          )
+        ] }, fieldPath);
+      }
+      if (fieldSchema.format === "multiline" || fieldSchema.format === "textarea") {
+        const isVarValue2 = isVariableReference(fieldValue);
+        return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+            /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+              fieldSchema.title || fieldName,
+              isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+            ] }),
+            renderVariablePicker(
+              fieldName,
+              "string",
+              fieldPath,
+              (varPath) => handleFieldChange(fieldName, (fieldValue || "") + varPath)
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            Textarea,
+            {
+              value: fieldValue || "",
+              onChange: (e) => handleFieldChange(fieldName, e.target.value),
+              disabled,
+              rows: 3,
+              className: cn("text-xs", isVarValue2 && "font-mono text-primary"),
+              placeholder: fieldSchema.description
+            }
+          ),
+          fieldSchema.description && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-muted-foreground", children: fieldSchema.description })
+        ] }, fieldPath);
+      }
+      const inputType = fieldSchema.format === "email" ? "email" : fieldSchema.format === "uri" || fieldSchema.format === "url" ? "url" : fieldSchema.format === "password" ? "password" : "text";
+      const isVarValue = isVariableReference(fieldValue);
+      return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+          fieldSchema.title || fieldName,
+          isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex gap-1.5", children: [
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              type: inputType,
+              value: fieldValue || "",
+              onChange: (e) => handleFieldChange(fieldName, e.target.value),
+              disabled,
+              className: cn("h-8 text-xs flex-1", isVarValue && "font-mono text-primary"),
+              placeholder: fieldSchema.description
+            }
+          ),
+          renderVariablePicker(
+            fieldName,
+            "string",
+            fieldPath,
+            (varPath) => handleFieldChange(fieldName, (fieldValue || "") + varPath)
+          )
+        ] }),
+        fieldSchema.description && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-muted-foreground", children: fieldSchema.description })
+      ] }, fieldPath);
+    }
+    return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+      /* @__PURE__ */ jsxs(Label, { className: "text-xs font-medium", children: [
+        fieldSchema.title || fieldName,
+        isRequired && /* @__PURE__ */ jsx("span", { className: "text-red-500 ml-0.5", children: "*" })
+      ] }),
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          value: typeof fieldValue === "object" ? JSON.stringify(fieldValue) : fieldValue || "",
+          onChange: (e) => {
+            try {
+              const parsed = JSON.parse(e.target.value);
+              handleFieldChange(fieldName, parsed);
+            } catch {
+              handleFieldChange(fieldName, e.target.value);
+            }
+          },
+          disabled,
+          className: "h-8 text-xs font-mono"
+        }
+      ),
+      /* @__PURE__ */ jsxs("p", { className: "text-[10px] text-muted-foreground", children: [
+        "Type: ",
+        fieldSchema.type || "unknown"
+      ] })
+    ] }, fieldPath);
+  };
+  if (schema.type === "object" && schema.properties) {
+    const sortedProperties = Object.entries(schema.properties).sort(
+      ([, a], [, b]) => {
+        const orderA = a["x-displayOrder"] ?? 999;
+        const orderB = b["x-displayOrder"] ?? 999;
+        return orderA - orderB;
+      }
+    );
+    return /* @__PURE__ */ jsx("div", { className: "space-y-3", children: sortedProperties.map(
+      ([fieldName, fieldSchema]) => renderField(fieldSchema, fieldName, value[fieldName])
+    ) });
+  }
+  return /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground text-center py-4", children: "No configuration required for this node." });
+}
+
+// components/schema-builder.tsx
+import { useState as useState2 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FIELD_TYPES = [
+  { value: "string", label: "Text" },
+  { value: "number", label: "Number" },
+  { value: "integer", label: "Integer" },
+  { value: "boolean", label: "Boolean" },
+  { value: "array", label: "Array" },
+  { value: "object", label: "Object" }
+];
+var STRING_FORMATS = [
+  { value: "plain", label: "Plain Text" },
+  { value: "email", label: "Email" },
+  { value: "uri", label: "URL" },
+  { value: "date", label: "Date" },
+  { value: "date-time", label: "Date & Time" },
+  { value: "multiline", label: "Multiline Text" }
+];
+function SchemaBuilder({
+  schema,
+  onChange,
+  disabled = false,
+  components
+}) {
+  const [expandedFields, setExpandedFields] = useState2(/* @__PURE__ */ new Set());
+  const {
+    Input,
+    Label,
+    Checkbox,
+    Select,
+    SelectTrigger,
+    SelectValue,
+    SelectContent,
+    SelectItem,
+    Button,
+    Card,
+    PlusIcon,
+    TrashIcon,
+    GripVerticalIcon,
+    ChevronDownIcon,
+    ChevronRightIcon
+  } = components;
+  const getFieldsFromSchema = () => {
+    if (!schema?.properties) return [];
+    return Object.entries(schema.properties).map(([name, prop]) => {
+      const fieldSchema = prop;
+      return {
+        name,
+        type: fieldSchema.type || "string",
+        title: fieldSchema.title || name,
+        description: fieldSchema.description || "",
+        required: schema.required?.includes(name) || false,
+        format: fieldSchema.format,
+        enum: fieldSchema.enum,
+        items: fieldSchema.items
+      };
+    });
+  };
+  const fields = getFieldsFromSchema();
+  const updateSchema = (newFields) => {
+    const properties = {};
+    const required = [];
+    newFields.forEach((field) => {
+      if (!field.name) return;
+      const fieldSchema = {
+        type: field.type,
+        title: field.title || field.name
+      };
+      if (field.description) {
+        fieldSchema.description = field.description;
+      }
+      if (field.format && field.format !== "plain") {
+        fieldSchema.format = field.format;
+      }
+      if (field.enum && field.enum.length > 0) {
+        fieldSchema.enum = field.enum;
+      }
+      if (field.type === "array" && field.items) {
+        fieldSchema.items = field.items;
+      }
+      properties[field.name] = fieldSchema;
+      if (field.required) {
+        required.push(field.name);
+      }
+    });
+    onChange({
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0
+    });
+  };
+  const addField = () => {
+    const newFieldName = `field_${fields.length + 1}`;
+    const newFields = [
+      ...fields,
+      {
+        name: newFieldName,
+        type: "string",
+        title: "",
+        description: "",
+        required: false
+      }
+    ];
+    updateSchema(newFields);
+    setExpandedFields((prev) => /* @__PURE__ */ new Set([...prev, newFieldName]));
+  };
+  const updateField = (index, updates) => {
+    const newFields = [...fields];
+    newFields[index] = { ...newFields[index], ...updates };
+    updateSchema(newFields);
+  };
+  const removeField = (index) => {
+    const newFields = fields.filter((_, i) => i !== index);
+    updateSchema(newFields);
+  };
+  const toggleExpand = (name) => {
+    setExpandedFields((prev) => {
+      const next = new Set(prev);
+      if (next.has(name)) {
+        next.delete(name);
+      } else {
+        next.add(name);
+      }
+      return next;
+    });
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "space-y-2", children: [
+    fields.length === 0 ? /* @__PURE__ */ jsx2("p", { className: "text-xs text-muted-foreground italic py-3", children: 'No fields defined. Click "Add Field" to create one.' }) : /* @__PURE__ */ jsx2("div", { className: "space-y-3", children: fields.map((field, index) => {
+      const isExpanded = expandedFields.has(field.name);
+      return /* @__PURE__ */ jsxs2(Card, { className: "p-3 bg-gray-50/50", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2 mb-2", children: [
+          /* @__PURE__ */ jsx2(GripVerticalIcon, { className: "h-4 w-4 text-gray-300 flex-shrink-0 cursor-grab" }),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              type: "button",
+              onClick: () => toggleExpand(field.name),
+              className: "flex-shrink-0 p-1 hover:bg-gray-200 rounded",
+              children: isExpanded ? /* @__PURE__ */ jsx2(ChevronDownIcon, { className: "h-4 w-4 text-gray-500" }) : /* @__PURE__ */ jsx2(ChevronRightIcon, { className: "h-4 w-4 text-gray-500" })
+            }
+          ),
+          /* @__PURE__ */ jsx2("div", { className: "flex-1", children: /* @__PURE__ */ jsx2(
+            Input,
+            {
+              value: field.name,
+              onChange: (e) => {
+                const oldName = field.name;
+                const newName = e.target.value.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "");
+                updateField(index, { name: newName });
+                if (expandedFields.has(oldName)) {
+                  setExpandedFields((prev) => {
+                    const next = new Set(prev);
+                    next.delete(oldName);
+                    next.add(newName);
+                    return next;
+                  });
+                }
+              },
+              placeholder: "field_name",
+              className: "h-9 text-sm font-mono",
+              disabled
+            }
+          ) }),
+          /* @__PURE__ */ jsx2(
+            Button,
+            {
+              type: "button",
+              variant: "ghost",
+              size: "sm",
+              className: "h-9 w-9 p-0 text-red-500 hover:text-red-700 hover:bg-red-50 flex-shrink-0",
+              onClick: () => removeField(index),
+              disabled,
+              children: /* @__PURE__ */ jsx2(TrashIcon, { className: "h-4 w-4" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-3 pl-10", children: [
+          /* @__PURE__ */ jsx2("div", { className: "flex-1", children: /* @__PURE__ */ jsxs2(
+            Select,
+            {
+              value: field.type,
+              onValueChange: (v) => updateField(index, { type: v }),
+              disabled,
+              children: [
+                /* @__PURE__ */ jsx2(SelectTrigger, { className: "h-9 text-sm", children: /* @__PURE__ */ jsx2(SelectValue, {}) }),
+                /* @__PURE__ */ jsx2(SelectContent, { children: FIELD_TYPES.map((type) => /* @__PURE__ */ jsx2(SelectItem, { value: type.value, children: type.label }, type.value)) })
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2 flex-shrink-0", children: [
+            /* @__PURE__ */ jsx2(
+              Checkbox,
+              {
+                id: `required-${index}`,
+                checked: field.required,
+                onCheckedChange: (checked) => updateField(index, { required: !!checked }),
+                disabled
+              }
+            ),
+            /* @__PURE__ */ jsx2(
+              Label,
+              {
+                htmlFor: `required-${index}`,
+                className: "text-sm text-muted-foreground",
+                children: "Required"
+              }
+            )
+          ] })
+        ] }),
+        isExpanded && /* @__PURE__ */ jsxs2("div", { className: "mt-3 pt-3 border-t space-y-3 pl-10", children: [
+          /* @__PURE__ */ jsxs2("div", { className: "space-y-1", children: [
+            /* @__PURE__ */ jsx2(Label, { className: "text-xs text-muted-foreground", children: "Display Title" }),
+            /* @__PURE__ */ jsx2(
+              Input,
+              {
+                value: field.title,
+                onChange: (e) => updateField(index, { title: e.target.value }),
+                placeholder: "Human readable title",
+                className: "h-9 text-sm",
+                disabled
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs2("div", { className: "space-y-1", children: [
+            /* @__PURE__ */ jsx2(Label, { className: "text-xs text-muted-foreground", children: "Description" }),
+            /* @__PURE__ */ jsx2(
+              Input,
+              {
+                value: field.description,
+                onChange: (e) => updateField(index, { description: e.target.value }),
+                placeholder: "Help text for this field",
+                className: "h-9 text-sm",
+                disabled
+              }
+            )
+          ] }),
+          field.type === "string" && /* @__PURE__ */ jsxs2("div", { className: "space-y-1", children: [
+            /* @__PURE__ */ jsx2(Label, { className: "text-xs text-muted-foreground", children: "Format" }),
+            /* @__PURE__ */ jsxs2(
+              Select,
+              {
+                value: field.format || "plain",
+                onValueChange: (v) => updateField(index, { format: v }),
+                disabled,
+                children: [
+                  /* @__PURE__ */ jsx2(SelectTrigger, { className: "h-9 text-sm", children: /* @__PURE__ */ jsx2(SelectValue, {}) }),
+                  /* @__PURE__ */ jsx2(SelectContent, { children: STRING_FORMATS.map((format) => /* @__PURE__ */ jsx2(SelectItem, { value: format.value, children: format.label }, format.value)) })
+                ]
+              }
+            )
+          ] }),
+          field.type === "array" && /* @__PURE__ */ jsxs2("div", { className: "space-y-1", children: [
+            /* @__PURE__ */ jsx2(Label, { className: "text-xs text-muted-foreground", children: "Item Type" }),
+            /* @__PURE__ */ jsxs2(
+              Select,
+              {
+                value: field.items?.type || "string",
+                onValueChange: (v) => updateField(index, { items: { type: v } }),
+                disabled,
+                children: [
+                  /* @__PURE__ */ jsx2(SelectTrigger, { className: "h-9 text-sm", children: /* @__PURE__ */ jsx2(SelectValue, {}) }),
+                  /* @__PURE__ */ jsx2(SelectContent, { children: FIELD_TYPES.filter((t) => t.value !== "array").map(
+                    (type) => /* @__PURE__ */ jsx2(SelectItem, { value: type.value, children: type.label }, type.value)
+                  ) })
+                ]
+              }
+            )
+          ] }),
+          field.type === "string" && /* @__PURE__ */ jsxs2("div", { className: "space-y-2", children: [
+            /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between", children: [
+              /* @__PURE__ */ jsx2(Label, { className: "text-xs text-muted-foreground", children: "Dropdown Options (optional)" }),
+              /* @__PURE__ */ jsxs2(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  className: "h-7 text-xs",
+                  onClick: () => {
+                    const currentEnum = field.enum || [];
+                    updateField(index, {
+                      enum: [
+                        ...currentEnum,
+                        `option_${currentEnum.length + 1}`
+                      ]
+                    });
+                  },
+                  disabled,
+                  children: [
+                    /* @__PURE__ */ jsx2(PlusIcon, { className: "h-3 w-3 mr-1" }),
+                    "Add Option"
+                  ]
+                }
+              )
+            ] }),
+            field.enum && field.enum.length > 0 && /* @__PURE__ */ jsx2("div", { className: "space-y-2", children: field.enum.map((option, optIdx) => /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+              /* @__PURE__ */ jsx2(
+                Input,
+                {
+                  value: option,
+                  onChange: (e) => {
+                    const newEnum = [...field.enum || []];
+                    newEnum[optIdx] = e.target.value;
+                    updateField(index, { enum: newEnum });
+                  },
+                  placeholder: `Option ${optIdx + 1}`,
+                  className: "h-8 text-sm flex-1",
+                  disabled
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                Button,
+                {
+                  type: "button",
+                  variant: "ghost",
+                  size: "sm",
+                  className: "h-8 w-8 p-0 text-red-400 hover:text-red-600",
+                  onClick: () => {
+                    const newEnum = (field.enum || []).filter(
+                      (_, i) => i !== optIdx
+                    );
+                    updateField(index, {
+                      enum: newEnum.length > 0 ? newEnum : void 0
+                    });
+                  },
+                  disabled,
+                  children: /* @__PURE__ */ jsx2(TrashIcon, { className: "h-3 w-3" })
+                }
+              )
+            ] }, optIdx)) })
+          ] })
+        ] })
+      ] }, index);
+    }) }),
+    /* @__PURE__ */ jsxs2(
+      Button,
+      {
+        type: "button",
+        variant: "outline",
+        size: "sm",
+        className: "w-full h-9 text-sm",
+        onClick: addField,
+        disabled,
+        children: [
+          /* @__PURE__ */ jsx2(PlusIcon, { className: "h-4 w-4 mr-2" }),
+          "Add Field"
+        ]
+      }
+    )
+  ] });
+}
+
+// context/workflow-definition-context.tsx
+import { createContext, useContext, useMemo as useMemo2 } from "react";
+
+// hooks/use-workflow-definition.ts
+import { useNatsContext } from "@elqnt/nats";
+import { useCallback, useEffect } from "react";
+import { useDispatch, useSelector } from "react-redux";
+
+// models/workflow.ts
+var NodeTypeTrigger = "trigger";
+var NodeTypeHumanAction = "humanAction";
+var NodeTypeAgent = "agent";
+var NodeTypeAction = "action";
+var NodeTypeLogic = "logic";
+var NodeTypeLoop = "loop";
+var NodeTypeParallel = "parallel";
+var NodeTypeDelay = "delay";
+var NodeTypeData = "data";
+var NodeTypeIntegration = "integration";
+var NodeTypeTimer = "timer";
+var NodeTypeSubflow = "subflow";
+var NodeTypeCustom = "custom";
+var NodeTypeAccounting = "accounting";
+var NodeSubTypeTriggerStart = "triggerStart";
+var NodeSubTypeTriggerEntityRecordCreated = "triggerEntityRecordCreated";
+var NodeSubTypeTriggerEntityRecordUpdated = "triggerEntityRecordUpdated";
+var NodeSubTypeTriggerEntityRecordDeleted = "triggerEntityRecordDeleted";
+var NodeSubTypeTriggerSLAWarning = "triggerSLAWarning";
+var NodeSubTypeTriggerSLABreach = "triggerSLABreach";
+var NodeSubTypeTriggerEscalation = "triggerEscalation";
+var NodeSubTypeTriggerWebhookReceived = "triggerWebhookReceived";
+var NodeSubTypeHumanActionReview = "humanActionReview";
+var NodeSubTypeHumanActionApproval = "humanActionApproval";
+var NodeSubTypeHumanActionDataEntry = "humanActionDataEntry";
+var NodeSubTypeHumanActionAssignment = "humanActionAssignment";
+var NodeSubTypeAgentChat = "agentChat";
+var NodeSubTypeAgentIntentDetector = "agentIntentDetector";
+var NodeSubTypeAgentKnowledgeGraph = "agentKnowledgeGraph";
+var NodeSubTypeAgentClientApiCall = "clientApiCall";
+var NodeSubTypeAgentTransferToHuman = "agentTransferToHuman";
+var NodeSubTypeAgentOpenTicket = "agentOpenTicket";
+var NodeSubTypeAgentApiIntegration = "agentApiIntegration";
+var NodeSubTypeAgentCustomResponse = "agentCustomResponse";
+var NodeSubTypeAgentStructuredOutput = "agentStructuredOutput";
+var NodeSubTypeActionApiCall = "actionApiCall";
+var NodeSubTypeActionDocumentExtraction = "actionDocumentExtraction";
+var NodeSubTypeActionSendEmail = "actionSendEmail";
+var NodeSubTypeActionSendSMS = "actionSendSMS";
+var NodeSubTypeActionGenerateDocument = "actionGenerateDocument";
+var NodeSubTypeActionProcessPayment = "actionProcessPayment";
+var NodeSubTypeActionCreateEntityRecord = "actionCreateEntityRecord";
+var NodeSubTypeActionUpdateEntityRecord = "actionUpdateEntityRecord";
+var NodeSubTypeActionDeleteEntityRecord = "actionDeleteEntityRecord";
+var NodeSubTypeActionMergeEntityRecords = "actionMergeEntityRecords";
+var NodeSubTypeActionAssignSLAPolicy = "actionAssignSLAPolicy";
+var NodeSubTypeActionChangeSLAStatus = "actionChangeSLAAssignmentStatus";
+var NodeSubTypeActionEscalateSLA = "actionEscalateSLAAssignment";
+var NodeSubTypeActionCSATSurvey = "actionCSATSurvey";
+var NodeSubTypeActionSetVariables = "actionSetVariables";
+var NodeSubTypeActionQueryEntityRecords = "actionQueryEntityRecords";
+var NodeSubTypeActionNatsRequest = "actionNatsRequest";
+var NodeSubTypeLogicIf = "logicIf";
+var NodeSubTypeLogicSwitch = "logicSwitch";
+var NodeSubTypeLogicFor = "logicFor";
+var NodeSubTypeLogicParallel = "logicParallel";
+var NodeSubTypeLoopData = "loopData";
+var NodeSubTypeDelay = "delay";
+var NodeSubTypeDataFilter = "dataFilter";
+var NodeSubTypeDataMap = "dataMap";
+var NodeSubTypeDataCalculate = "dataCalculate";
+var NodeSubTypeDataValidate = "dataValidate";
+var NodeSubTypeTimerDelay = "timerDelay";
+var NodeSubTypeTimerSchedule = "timerSchedule";
+var NodeSubTypeTimerBusinessHours = "timerBusinessHours";
+var ExpressionTypeFilter = "filter";
+var ExpressionTypeJavaScript = "javascript";
+var ExpressionTypeTemplate = "template";
+var ExpressionTypeDSL = "dsl";
+var ExpressionTypeRules = "rules";
+var EdgeTypeNormal = "normal";
+var EdgeTypeLoopBack = "loopBack";
+var EdgeTypeError = "error";
+var EdgeTypeDefault = "default";
+var EdgeTypeParallel = "parallel";
+var EdgeTypeConditional = "conditional";
+var EdgeTypeMerge = "merge";
+var EdgeTypeCompensation = "compensation";
+var EdgeTypeTimeout = "timeout";
+var WorkflowTypeEntity = "entity";
+var WorkflowTypeDocument = "document";
+var WorkflowTypeChat = "chat";
+var WorkflowTypeAgent = "agent";
+var WorkflowTypeProductivity = "productivity";
+var RuleLevelError = "error";
+var RuleLevelWarning = "warning";
+var RuleLevelInfo = "info";
+var PersistenceTypeEphemeral = "ephemeral";
+var PersistenceTypePermanent = "permanent";
+var TimeoutActionFail = "fail";
+var TimeoutActionSkip = "skip";
+var TimeoutActionRetry = "retry";
+var TimeoutActionAlt = "alt";
+var InstanceStatusNew = "NEW";
+var InstanceStatusRunning = "RUNNING";
+var InstanceStatusWaiting = "WAITING";
+var InstanceStatusPaused = "PAUSED";
+var InstanceStatusCompleted = "COMPLETED";
+var InstanceStatusFailed = "FAILED";
+var NodeStatusPending = "PENDING";
+var NodeStatusRunning = "RUNNING";
+var NodeStatusCompleted = "COMPLETED";
+var NodeStatusFailed = "FAILED";
+var NodeStatusWaiting = "WAITING";
+var NodeStatusSkipped = "SKIPPED";
+var EdgeStatusPending = "PENDING";
+var EdgeStatusCompleted = "COMPLETED";
+var EdgeStatusSkipped = "SKIPPED";
+
+// models/subjects.ts
+var WorkflowDefinitionCreate = "workflow.definition.create";
+var WorkflowDefinitionCreated = "workflow.definition.created";
+var WorkflowDefinitionUpdate = "workflow.definition.update";
+var WorkflowDefinitionUpdated = "workflow.definition.updated";
+var WorkflowDefinitionGet = "workflow.definition.get";
+var WorkflowDefinitionGetServer = "workflow.definition.get.server";
+var WorkflowDefinitionGetByTitle = "workflow.definition.get.by.title";
+var WorkflowDefinitionList = "workflow.definition.list";
+var WorkflowDefinitionDelete = "workflow.definition.delete";
+var WorkflowDefinitionDeleted = "workflow.definition.deleted";
+var WorkflowInstanceCreate = "workflow.instance.create";
+var WorkflowInstanceExecuteNode = "workflow.instance.execute.node";
+var WorkflowInstanceResumeNode = "workflow.instance.resume.node";
+var WorkflowInstanceExecuteNodeServer = "workflow.instance.execute.node.server";
+var WorkflowInstanceResumeNodeServer = "workflow.instance.resume.node.server";
+var WorkflowInstanceExecuteNodeLean = "workflow.instance.execute.node.lean";
+var WorkflowInstanceExecuteNodeLeanServer = "workflow.instance.execute.node.lean.server";
+var WorkflowInstanceGet = "workflow.instance.get";
+var WorkflowInstanceList = "workflow.instance.list";
+var WorkflowInstanceUpdate = "workflow.instance.update";
+var WorkflowInstanceUpdated = "workflow.instance.updated";
+var WorkflowInstanceUpdateNodeMetadata = "workflow.instance.update.node.metadata";
+var WorkflowTemplateList = "workflow.template.list";
+var WorkflowTemplateGet = "workflow.template.get";
+var WorkflowTemplateInstantiate = "workflow.template.instantiate";
+var WorkflowScheduleCreate = "workflow.schedule.create";
+var WorkflowScheduleUpdate = "workflow.schedule.update";
+var WorkflowScheduleDelete = "workflow.schedule.delete";
+var WorkflowScheduleList = "workflow.schedule.list";
+var WorkflowSchedulePause = "workflow.schedule.pause";
+var WorkflowScheduleResume = "workflow.schedule.resume";
+var WorkflowTriggerRegister = "workflow.trigger.register";
+var WorkflowTriggerPause = "workflow.trigger.pause";
+var WorkflowTriggerResume = "workflow.trigger.resume";
+var WorkflowTriggerStatus = "workflow.trigger.status";
+var WorkflowTriggerFired = "workflow.trigger.fired";
+var WorkflowExecutionStarted = "workflow.execution.started";
+var WorkflowExecutionCompleted = "workflow.execution.completed";
+var WorkflowExecutionFailed = "workflow.execution.failed";
+
+// store/workflow-definition-slice.ts
+import { createSlice } from "@reduxjs/toolkit";
+var initialState = {
+  definitions: {},
+  isLoading: false,
+  loadingStates: {}
+};
+var workflowDefinitionSlice = createSlice({
+  name: "workflowDefinition",
+  initialState,
+  reducers: {
+    setLoading: (state, action) => {
+      state.isLoading = action.payload;
+    },
+    setOperationLoading: (state, action) => {
+      state.loadingStates[action.payload.operation] = action.payload.loading;
+    },
+    setError: (state, action) => {
+      state.error = action.payload;
+    },
+    setDefinitions: (state, action) => {
+      state.definitions = action.payload.reduce(
+        (acc, def) => {
+          if (def.id) {
+            acc[def.id] = def;
+          }
+          return acc;
+        },
+        {}
+      );
+    },
+    addDefinition: (state, action) => {
+      const definition = action.payload;
+      if (definition.id) {
+        state.definitions[definition.id] = definition;
+      }
+    },
+    updateDefinition: (state, action) => {
+      const definition = action.payload;
+      if (definition.id) {
+        state.definitions[definition.id] = definition;
+      }
+      if (state.selectedDefinition?.id === definition.id) {
+        state.selectedDefinition = definition;
+      }
+    },
+    removeDefinition: (state, action) => {
+      delete state.definitions[action.payload];
+      if (state.selectedDefinition?.id === action.payload) {
+        state.selectedDefinition = void 0;
+      }
+    },
+    setSelectedDefinition: (state, action) => {
+      state.selectedDefinition = action.payload;
+    }
+  }
+});
+var {
+  setLoading,
+  setOperationLoading,
+  setError,
+  setDefinitions,
+  addDefinition,
+  updateDefinition,
+  removeDefinition,
+  setSelectedDefinition
+} = workflowDefinitionSlice.actions;
+var workflowDefinitionReducer = workflowDefinitionSlice.reducer;
+
+// hooks/use-workflow-definition.ts
+function useWorkflowDefinition(orgId, definitionId, options = {}) {
+  const { autoLoad } = options;
+  const { natsConnected, request } = useNatsContext();
+  const dispatch = useDispatch();
+  const definitions = useSelector(
+    (state) => state.workflowDefinition.definitions
+  );
+  const selectedDefinition = useSelector(
+    (state) => state.workflowDefinition.selectedDefinition
+  );
+  const isLoading = useSelector(
+    (state) => state.workflowDefinition.isLoading
+  );
+  const loadingStates = useSelector(
+    (state) => state.workflowDefinition.loadingStates
+  );
+  const error = useSelector(
+    (state) => state.workflowDefinition.error
+  );
+  const loadDefinitions = useCallback(async () => {
+    if (!natsConnected || !orgId) return;
+    const loadingKey = "loadDefinitions";
+    if (loadingStates[loadingKey]) return;
+    dispatch(setOperationLoading({ operation: loadingKey, loading: true }));
+    try {
+      const response = await request(WorkflowDefinitionList, { orgId });
+      if (response instanceof Error) {
+        dispatch(setError(response.message));
+      } else {
+        dispatch(setDefinitions(response?.definitions ?? []));
+      }
+    } catch (err) {
+      dispatch(setError(err instanceof Error ? err.message : "Unknown error"));
+    } finally {
+      dispatch(setOperationLoading({ operation: loadingKey, loading: false }));
+    }
+  }, [natsConnected, orgId, dispatch, request]);
+  const loadDefinition = useCallback(
+    async (id) => {
+      if (!natsConnected || !orgId) return;
+      dispatch(setOperationLoading({ operation: `load_${id}`, loading: true }));
+      try {
+        const response = await request(WorkflowDefinitionGet, { id, orgId });
+        if (response instanceof Error) {
+          dispatch(setError(response.message));
+          return;
+        }
+        dispatch(setSelectedDefinition(response.definition));
+      } finally {
+        dispatch(
+          setOperationLoading({ operation: `load_${id}`, loading: false })
+        );
+      }
+    },
+    [natsConnected, orgId, dispatch, request]
+  );
+  const resetSelectedDefinition = useCallback(() => {
+    dispatch(setSelectedDefinition(void 0));
+  }, [dispatch]);
+  const createDefinition = async (definition) => {
+    if (!natsConnected || !orgId) {
+      throw new Error("Not connected or missing orgId");
+    }
+    dispatch(setOperationLoading({ operation: "create", loading: true }));
+    try {
+      const response = await request(WorkflowDefinitionCreate, { definition, orgId });
+      if (response instanceof Error) {
+        throw response;
+      }
+      if (response.metadata.success) {
+        dispatch(addDefinition(response.definition));
+      }
+      return response;
+    } finally {
+      dispatch(setOperationLoading({ operation: "create", loading: false }));
+    }
+  };
+  const updateDefinitionById = async (id, definition) => {
+    if (!natsConnected || !orgId) {
+      throw new Error("Not connected or missing orgId");
+    }
+    dispatch(setOperationLoading({ operation: `update_${id}`, loading: true }));
+    try {
+      const response = await request(WorkflowDefinitionUpdate, {
+        definition,
+        orgId
+      });
+      if (response instanceof Error) {
+        throw response;
+      }
+      if (response.metadata.success) {
+        dispatch(updateDefinition(response.definition));
+      }
+      return response;
+    } finally {
+      dispatch(
+        setOperationLoading({ operation: `update_${id}`, loading: false })
+      );
+    }
+  };
+  const deleteDefinition = async (id) => {
+    if (!natsConnected || !orgId) {
+      throw new Error("Not connected or missing orgId");
+    }
+    dispatch(setOperationLoading({ operation: `delete_${id}`, loading: true }));
+    try {
+      const response = await request(WorkflowDefinitionDelete, { id, orgId });
+      if (response instanceof Error) {
+        throw response;
+      }
+      dispatch(removeDefinition(id));
+      return response;
+    } finally {
+      dispatch(
+        setOperationLoading({ operation: `delete_${id}`, loading: false })
+      );
+    }
+  };
+  const refresh = useCallback(() => {
+    if (!natsConnected || !orgId) return;
+    if (definitionId) {
+      loadDefinition(definitionId);
+    } else {
+      dispatch(setLoading(true));
+      loadDefinitions().finally(() => dispatch(setLoading(false)));
+    }
+  }, [natsConnected, orgId, definitionId, loadDefinition, dispatch]);
+  useEffect(() => {
+    let mounted = true;
+    if (autoLoad && natsConnected && orgId && mounted) {
+      loadDefinitions();
+    }
+    return () => {
+      mounted = false;
+    };
+  }, [autoLoad, natsConnected, orgId]);
+  useEffect(() => {
+    if (natsConnected && orgId && definitionId) {
+      loadDefinition(definitionId);
+    }
+  }, [natsConnected, orgId, definitionId, loadDefinition]);
+  return {
+    // State
+    definitions,
+    selectedDefinition,
+    isLoading,
+    loadingStates,
+    error,
+    // Operations
+    loadDefinitions,
+    loadDefinition,
+    resetSelectedDefinition,
+    createDefinition,
+    updateDefinition: updateDefinitionById,
+    deleteDefinition,
+    // Utilities
+    refresh
+  };
+}
+
+// hooks/use-workflow-instance.ts
+import { useNatsContext as useNatsContext2 } from "@elqnt/nats";
+import { useCallback as useCallback2, useEffect as useEffect2 } from "react";
+import { useDispatch as useDispatch2, useSelector as useSelector2 } from "react-redux";
+
+// store/workflow-instance-slice.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var initialState2 = {
+  instances: {},
+  isLoading: false,
+  loadingStates: {}
+};
+var workflowInstanceSlice = createSlice2({
+  name: "workflowInstance",
+  initialState: initialState2,
+  reducers: {
+    setLoading: (state, action) => {
+      state.isLoading = action.payload;
+    },
+    setOperationLoading: (state, action) => {
+      state.loadingStates[action.payload.operation] = action.payload.loading;
+    },
+    setError: (state, action) => {
+      state.error = action.payload;
+    },
+    setInstances: (state, action) => {
+      state.instances = action.payload.reduce(
+        (acc, inst) => {
+          if (inst.id) {
+            acc[inst.id] = inst;
+          }
+          return acc;
+        },
+        {}
+      );
+    },
+    updateInstance: (state, action) => {
+      const instance = action.payload;
+      if (instance.id) {
+        state.instances[instance.id] = instance;
+      }
+      if (state.selectedInstance?.id === instance.id) {
+        state.selectedInstance = instance;
+      }
+    },
+    setSelectedInstance: (state, action) => {
+      state.selectedInstance = action.payload;
+    }
+  }
+});
+var {
+  setLoading: setLoading2,
+  setOperationLoading: setOperationLoading2,
+  setError: setError2,
+  setInstances,
+  updateInstance,
+  setSelectedInstance
+} = workflowInstanceSlice.actions;
+var workflowInstanceReducer = workflowInstanceSlice.reducer;
+
+// hooks/use-workflow-instance.ts
+function useWorkflowInstance(orgId, instanceId, definitionId, options = {}) {
+  const { autoLoad } = options;
+  const { natsConnected, request } = useNatsContext2();
+  const dispatch = useDispatch2();
+  const instances = useSelector2(
+    (state) => state.workflowInstance.instances
+  );
+  const selectedInstance = useSelector2(
+    (state) => state.workflowInstance.selectedInstance
+  );
+  const isLoading = useSelector2(
+    (state) => state.workflowInstance.isLoading
+  );
+  const loadingStates = useSelector2(
+    (state) => state.workflowInstance.loadingStates
+  );
+  const error = useSelector2(
+    (state) => state.workflowInstance.error
+  );
+  const loadInstances = useCallback2(
+    async (defId) => {
+      if (!natsConnected || !orgId) return;
+      const loadingKey = `loadInstances_${defId}`;
+      if (loadingStates[loadingKey]) return;
+      dispatch(setOperationLoading2({ operation: loadingKey, loading: true }));
+      try {
+        const response = await request(WorkflowInstanceList, {
+          orgId,
+          definitionId: defId
+        });
+        if (response instanceof Error) {
+          dispatch(setError2(response.message));
+        } else {
+          dispatch(setInstances(response?.instances ?? []));
+        }
+      } catch (err) {
+        dispatch(
+          setError2(err instanceof Error ? err.message : "Unknown error")
+        );
+      } finally {
+        dispatch(
+          setOperationLoading2({ operation: loadingKey, loading: false })
+        );
+      }
+    },
+    [natsConnected, orgId, dispatch, request]
+  );
+  const loadInstance = useCallback2(
+    async (id) => {
+      if (!natsConnected || !orgId) return;
+      dispatch(setOperationLoading2({ operation: `load_${id}`, loading: true }));
+      try {
+        const response = await request(WorkflowInstanceGet, {
+          orgId,
+          instanceId: id
+        });
+        if (response instanceof Error) {
+          dispatch(setError2(response.message));
+          return;
+        }
+        dispatch(setSelectedInstance(response.instance));
+      } finally {
+        dispatch(
+          setOperationLoading2({ operation: `load_${id}`, loading: false })
+        );
+      }
+    },
+    [natsConnected, orgId, dispatch, request]
+  );
+  const doSetSelectedInstance = useCallback2(
+    (instance) => {
+      dispatch(setSelectedInstance(instance));
+    },
+    [dispatch]
+  );
+  const getInstance = async (id) => {
+    const response = await request(WorkflowInstanceGet, {
+      orgId: orgId ?? "",
+      instanceId: id
+    });
+    return response;
+  };
+  const createInstance = async (defId, variables) => {
+    if (!natsConnected || !orgId) {
+      throw new Error("Not connected or missing orgId");
+    }
+    dispatch(setOperationLoading2({ operation: "create", loading: true }));
+    try {
+      const response = await request(WorkflowInstanceCreate, {
+        orgId,
+        definitionId: defId,
+        variables: variables ?? {},
+        autoExecute: true
+      });
+      if (response instanceof Error) {
+        throw response;
+      }
+      if (response.metadata.success && response.instance) {
+        dispatch(updateInstance(response.instance));
+      }
+      return response;
+    } finally {
+      dispatch(setOperationLoading2({ operation: "create", loading: false }));
+    }
+  };
+  const executeNode = async (instId, nodeId, input) => {
+    if (!natsConnected || !orgId) {
+      throw new Error("Not connected or missing orgId");
+    }
+    dispatch(
+      setOperationLoading2({ operation: `execute_${nodeId}`, loading: true })
+    );
+    try {
+      const response = await request(WorkflowInstanceExecuteNode, {
+        orgId,
+        instanceId: instId,
+        nodeId,
+        input
+      });
+      if (response instanceof Error) {
+        throw response;
+      }
+      if (response.metadata.success && response.instance) {
+        dispatch(updateInstance(response.instance));
+      }
+      return response;
+    } finally {
+      dispatch(
+        setOperationLoading2({ operation: `execute_${nodeId}`, loading: false })
+      );
+    }
+  };
+  const updateInstanceNodeMetadata = async (instanceId2, nodeId, metadataKey, payload) => {
+    if (!natsConnected || !orgId) {
+      throw new Error("Not connected or missing orgId");
+    }
+    dispatch(
+      setOperationLoading2({ operation: `update_${nodeId}`, loading: true })
+    );
+    try {
+      const response = await request(WorkflowInstanceUpdateNodeMetadata, {
+        orgId,
+        instanceId: instanceId2,
+        nodeId,
+        metadataKey,
+        payload
+      });
+      if (response instanceof Error) {
+        throw response;
+      }
+      if (response.metadata.success && response.instance) {
+        dispatch(updateInstance(response.instance));
+      }
+      return response;
+    } finally {
+      dispatch(
+        setOperationLoading2({ operation: `update_${nodeId}`, loading: false })
+      );
+    }
+  };
+  const resumeInstanceNode = async (instanceId2, nodeId, result) => {
+    if (!natsConnected || !orgId) {
+      throw new Error("Not connected or missing orgId");
+    }
+    dispatch(
+      setOperationLoading2({ operation: `update_${nodeId}`, loading: true })
+    );
+    try {
+      const response = await request(WorkflowInstanceResumeNode, {
+        orgId,
+        instanceId: instanceId2,
+        nodeId,
+        result
+      });
+      if (response instanceof Error) {
+        throw response;
+      }
+      if (response.metadata.success && response.instance) {
+        dispatch(updateInstance(response.instance));
+      }
+      return response;
+    } finally {
+      dispatch(
+        setOperationLoading2({ operation: `update_${nodeId}`, loading: false })
+      );
+    }
+  };
+  const refresh = useCallback2(() => {
+    if (!natsConnected || !orgId) return;
+    if (instanceId) {
+      loadInstance(instanceId);
+    } else if (definitionId) {
+      dispatch(setLoading2(true));
+      loadInstances(definitionId).finally(() => dispatch(setLoading2(false)));
+    }
+  }, [natsConnected, orgId, instanceId, definitionId, loadInstance, dispatch]);
+  useEffect2(() => {
+    let mounted = true;
+    if (autoLoad && natsConnected && orgId && mounted) {
+      if (instanceId) {
+        loadInstance(instanceId);
+      } else if (definitionId) {
+        loadInstances(definitionId);
+      }
+    }
+    return () => {
+      mounted = false;
+    };
+  }, [autoLoad, natsConnected, orgId, instanceId, definitionId]);
+  return {
+    // State
+    instances,
+    selectedInstance,
+    doSetSelectedInstance,
+    isLoading,
+    loadingStates,
+    error,
+    // Operations
+    loadInstances,
+    loadInstance,
+    getInstance,
+    createInstance,
+    executeNode,
+    updateInstanceNodeMetadata,
+    resumeInstanceNode,
+    // Utilities
+    refresh
+  };
+}
+
+// context/workflow-definition-context.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var WorkflowDefinitionContext = createContext(void 0);
+function WorkflowDefinitionProvider({
+  children,
+  orgId,
+  definitionId,
+  options = {}
+}) {
+  const hookValue = useWorkflowDefinition(orgId, definitionId, options);
+  const value = useMemo2(() => hookValue, [hookValue]);
+  return /* @__PURE__ */ jsx3(WorkflowDefinitionContext.Provider, { value, children });
+}
+function useWorkflowDefinitionContext() {
+  const context = useContext(WorkflowDefinitionContext);
+  if (!context) {
+    throw new Error(
+      "useWorkflowDefinitionContext must be used within an WorkflowDefinitionProvider"
+    );
+  }
+  return context;
+}
+
+// context/workflow-instance-context.tsx
+import { createContext as createContext2, useContext as useContext2, useMemo as useMemo3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var WorkflowInstanceContext = createContext2(void 0);
+function WorkflowInstanceProvider({
+  children,
+  orgId,
+  instanceId,
+  definitionId,
+  options = {}
+}) {
+  const hookValue = useWorkflowInstance(
+    orgId,
+    instanceId,
+    definitionId,
+    options
+  );
+  const value = useMemo3(() => hookValue, [hookValue]);
+  return /* @__PURE__ */ jsx4(WorkflowInstanceContext.Provider, { value, children });
+}
+function useWorkflowInstanceContext() {
+  const context = useContext2(WorkflowInstanceContext);
+  if (!context) {
+    throw new Error(
+      "useWorkflowInstanceContext must be used within an WorkflowInstanceProvider"
+    );
+  }
+  return context;
+}
+
+// schema/schemas.ts
+var nodeDefinitions = {
+  "actionAIClassify": {
+    "type": "agent",
+    "subType": "actionAIClassify",
+    "label": "AI Classify",
+    "icon": "Tags",
+    "description": "Classify content into categories using AI",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "AI Classify",
+      "properties": {
+        "categories": {
+          "type": "array",
+          "title": "Categories",
+          "description": "List of possible categories",
+          "items": {
+            "type": "string"
+          }
+        },
+        "content": {
+          "type": "string",
+          "title": "Content",
+          "format": "multiline"
+        },
+        "instructions": {
+          "type": "string",
+          "title": "Additional Instructions",
+          "format": "multiline"
+        },
+        "multiLabel": {
+          "type": "boolean",
+          "title": "Allow Multiple Labels",
+          "description": "Can content belong to multiple categories?",
+          "default": false
+        }
+      },
+      "required": [
+        "content",
+        "categories"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "categories": {
+          "type": "array",
+          "title": "Categories",
+          "items": {
+            "type": "string"
+          }
+        },
+        "category": {
+          "type": "string",
+          "title": "Primary Category"
+        },
+        "confidence": {
+          "type": "number",
+          "title": "Confidence",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "reasoning": {
+          "type": "string",
+          "title": "Reasoning"
+        }
+      }
+    }
+  },
+  "actionAIExtractData": {
+    "type": "agent",
+    "subType": "actionAIExtractData",
+    "label": "AI Extract Data",
+    "icon": "FileSearch",
+    "description": "Extract structured data from unstructured content",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "AI Extract Data",
+      "properties": {
+        "content": {
+          "type": "string",
+          "title": "Content",
+          "format": "multiline"
+        },
+        "extractionSchema": {
+          "type": "object",
+          "title": "Extraction Schema",
+          "description": "JSON Schema defining what to extract"
+        },
+        "instructions": {
+          "type": "string",
+          "title": "Instructions",
+          "format": "multiline"
+        }
+      },
+      "required": [
+        "content",
+        "extractionSchema"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "description": "Extracted data matching the schema"
+    }
+  },
+  "actionAISummarize": {
+    "type": "agent",
+    "subType": "actionAISummarize",
+    "label": "AI Summarize",
+    "icon": "FileText",
+    "description": "Summarize text content using AI",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "AI Summarize",
+      "properties": {
+        "content": {
+          "type": "string",
+          "title": "Content",
+          "description": "Text to summarize (supports {{variables}})",
+          "format": "multiline"
+        },
+        "focusOn": {
+          "type": "string",
+          "title": "Focus On",
+          "description": "Optional: specific aspects to focus on"
+        },
+        "maxLength": {
+          "type": "integer",
+          "title": "Max Length (words)",
+          "minimum": 10,
+          "maximum": 1e3
+        },
+        "style": {
+          "type": "string",
+          "title": "Style",
+          "default": "brief",
+          "enum": [
+            "brief",
+            "detailed",
+            "bullet_points",
+            "executive"
+          ],
+          "x-enumLabels": [
+            "Brief (1-2 sentences)",
+            "Detailed",
+            "Bullet Points",
+            "Executive Summary"
+          ]
+        }
+      },
+      "required": [
+        "content",
+        "style"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "keyPoints": {
+          "type": "array",
+          "title": "Key Points",
+          "items": {
+            "type": "string"
+          }
+        },
+        "summary": {
+          "type": "string",
+          "title": "Summary"
+        },
+        "wordCount": {
+          "type": "integer",
+          "title": "Word Count"
+        }
+      }
+    }
+  },
+  "actionApiCall": {
+    "type": "action",
+    "subType": "actionApiCall",
+    "label": "API Call",
+    "icon": "Globe",
+    "description": "Make HTTP API requests",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "API Call",
+      "properties": {
+        "authorization": {
+          "type": "string",
+          "title": "Authorization",
+          "x-displayOrder": 5
+        },
+        "callbackTimeout": {
+          "type": "integer",
+          "title": "Callback Timeout (ms)",
+          "description": "For async mode only",
+          "x-displayOrder": 9
+        },
+        "headers": {
+          "type": "object",
+          "title": "Headers",
+          "x-displayOrder": 4
+        },
+        "method": {
+          "type": "string",
+          "title": "HTTP Method",
+          "enum": [
+            "GET",
+            "POST",
+            "PUT",
+            "DELETE",
+            "PATCH"
+          ],
+          "x-displayOrder": 3
+        },
+        "mode": {
+          "type": "string",
+          "title": "Mode",
+          "enum": [
+            "sync",
+            "async"
+          ],
+          "x-enumLabels": [
+            "Synchronous",
+            "Asynchronous (Callback)"
+          ],
+          "x-displayOrder": 1
+        },
+        "retryCount": {
+          "type": "integer",
+          "title": "Retry Count",
+          "minimum": 0,
+          "maximum": 5,
+          "x-displayOrder": 7
+        },
+        "retryDelay": {
+          "type": "integer",
+          "title": "Retry Delay (ms)",
+          "minimum": 100,
+          "x-displayOrder": 8
+        },
+        "timeout": {
+          "type": "integer",
+          "title": "Timeout (ms)",
+          "minimum": 1e3,
+          "maximum": 3e5,
+          "x-displayOrder": 6
+        },
+        "url": {
+          "type": "string",
+          "title": "URL",
+          "x-displayOrder": 2
+        }
+      },
+      "required": [
+        "url",
+        "method"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "actionAssignSLAPolicy": {
+    "type": "action",
+    "subType": "actionAssignSLAPolicy",
+    "label": "Assign SLA Policy",
+    "icon": "Clock",
+    "description": "Assign an SLA policy to a record",
+    "category": "Data Operations",
+    "config": {
+      "type": "object",
+      "title": "Assign SLA Policy",
+      "properties": {
+        "entityRecordIdExpr": {
+          "type": "string",
+          "title": "Entity Record ID"
+        },
+        "policyId": {
+          "type": "string",
+          "title": "Policy ID"
+        }
+      },
+      "required": [
+        "policyId"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "assignmentId": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "actionCreateEntityRecord": {
+    "type": "action",
+    "subType": "actionCreateEntityRecord",
+    "label": "Create Entity Record",
+    "icon": "FilePlus",
+    "description": "Create a new entity record",
+    "category": "Data Operations",
+    "config": {
+      "type": "object",
+      "title": "Create Entity Record",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "fields": {
+          "type": "object",
+          "title": "Field Values"
+        }
+      },
+      "required": [
+        "entityName"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "recordId": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "actionDeleteEntityRecord": {
+    "type": "action",
+    "subType": "actionDeleteEntityRecord",
+    "label": "Delete Entity Record",
+    "icon": "FileX",
+    "description": "Delete an entity record",
+    "category": "Data Operations",
+    "config": {
+      "type": "object",
+      "title": "Delete Entity Record",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "recordIdExpr": {
+          "type": "string",
+          "title": "Record ID Expression"
+        }
+      },
+      "required": [
+        "entityName",
+        "recordIdExpr"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "deleted": {
+          "type": "boolean"
+        }
+      }
+    }
+  },
+  "actionDocumentExtraction": {
+    "type": "action",
+    "subType": "actionDocumentExtraction",
+    "label": "Document Extraction",
+    "icon": "FileSearch",
+    "description": "Extract data from documents using AI",
+    "category": "Data Processing",
+    "config": {
+      "type": "object",
+      "title": "Document Extraction",
+      "properties": {
+        "documentType": {
+          "type": "string",
+          "title": "Document Type"
+        },
+        "instructions": {
+          "type": "string",
+          "title": "Instructions",
+          "format": "multiline"
+        }
+      },
+      "required": [
+        "instructions",
+        "documentType"
+      ]
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "fileUrl": {
+          "type": "string"
+        }
+      }
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "actionNatsRequest": {
+    "type": "action",
+    "subType": "actionNatsRequest",
+    "label": "NATS Request",
+    "icon": "Send",
+    "description": "Execute a NATS request-reply call with dynamic subject routing",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "NATS Request",
+      "properties": {
+        "actionTypeField": {
+          "type": "string",
+          "title": "Action Type Field",
+          "description": 'Dot-notation path to get action type from input (e.g., "human_review.selectedAction.type")'
+        },
+        "payloadTemplate": {
+          "type": "object",
+          "title": "Payload Template",
+          "description": "JSON payload with {{variable}} interpolation"
+        },
+        "subjectMapping": {
+          "type": "object",
+          "title": "Subject Mapping",
+          "description": 'Map action types to NATS subjects (e.g., {"reply": "hub.integration.email.send"})'
+        },
+        "timeoutSeconds": {
+          "type": "integer",
+          "title": "Timeout (seconds)",
+          "default": 30,
+          "minimum": 1,
+          "maximum": 300
+        }
+      }
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "subject": {
+          "type": "string",
+          "title": "NATS Subject",
+          "description": "Direct NATS subject (alternative to subjectMapping)"
+        }
+      }
+    },
+    "output": {
+      "type": "object",
+      "description": "Response from NATS service",
+      "properties": {
+        "_actionType": {
+          "type": "string",
+          "title": "Action Type",
+          "description": "The action type that was used (if subjectMapping was used)"
+        },
+        "_executedSubject": {
+          "type": "string",
+          "title": "Executed Subject",
+          "description": "The NATS subject that was called"
+        }
+      }
+    }
+  },
+  "actionQueryEntityRecords": {
+    "type": "action",
+    "subType": "actionQueryEntityRecords",
+    "label": "Query Entity Records",
+    "icon": "Search",
+    "description": "Query entity records with filters",
+    "category": "Data Operations",
+    "config": {
+      "type": "object",
+      "title": "Query Entity Records",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name",
+          "description": "Name of the entity to query"
+        },
+        "filters": {
+          "type": "object",
+          "title": "Filters",
+          "description": 'Field filters (e.g., {"status": "open"})'
+        },
+        "page": {
+          "type": "integer",
+          "title": "Page",
+          "description": "Page number (default: 1)",
+          "minimum": 1
+        },
+        "pageSize": {
+          "type": "integer",
+          "title": "Page Size",
+          "description": "Records per page (default: 10)",
+          "minimum": 1,
+          "maximum": 100
+        },
+        "sortBy": {
+          "type": "string",
+          "title": "Sort By",
+          "description": "Field to sort by"
+        },
+        "sortOrder": {
+          "type": "integer",
+          "title": "Sort Order",
+          "description": "1 for ascending, -1 for descending",
+          "enum": [
+            1,
+            -1
+          ]
+        }
+      },
+      "required": [
+        "entityName"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "page": {
+          "type": "integer",
+          "title": "Current Page"
+        },
+        "pageSize": {
+          "type": "integer",
+          "title": "Page Size"
+        },
+        "records": {
+          "type": "array",
+          "title": "Records",
+          "description": "Array of matching entity records",
+          "items": {
+            "type": "object"
+          }
+        },
+        "totalCount": {
+          "type": "integer",
+          "title": "Total Count",
+          "description": "Total number of matching records"
+        },
+        "totalPages": {
+          "type": "integer",
+          "title": "Total Pages"
+        }
+      }
+    }
+  },
+  "actionSendEmail": {
+    "type": "action",
+    "subType": "actionSendEmail",
+    "label": "Send Email",
+    "icon": "Mail",
+    "description": "Send an email notification",
+    "category": "Communication",
+    "config": {
+      "type": "object",
+      "title": "Send Email",
+      "properties": {
+        "bcc": {
+          "type": "string",
+          "title": "BCC"
+        },
+        "body": {
+          "type": "string",
+          "title": "Body",
+          "format": "multiline"
+        },
+        "cc": {
+          "type": "string",
+          "title": "CC"
+        },
+        "from": {
+          "type": "string",
+          "title": "From",
+          "description": "Sender email address (must be verified in SES)"
+        },
+        "subject": {
+          "type": "string",
+          "title": "Subject"
+        },
+        "template": {
+          "type": "string",
+          "title": "Template",
+          "enum": [
+            "welcome",
+            "notification",
+            "confirmation",
+            "custom"
+          ],
+          "x-enumLabels": [
+            "Welcome Email",
+            "Notification",
+            "Confirmation",
+            "Custom"
+          ]
+        },
+        "to": {
+          "type": "string",
+          "title": "To"
+        }
+      },
+      "required": [
+        "from",
+        "to",
+        "subject"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "emailSent": {
+          "type": "boolean"
+        }
+      }
+    }
+  },
+  "actionSendSMS": {
+    "type": "action",
+    "subType": "actionSendSMS",
+    "label": "Send SMS",
+    "icon": "Smartphone",
+    "description": "Send an SMS message",
+    "category": "Communication",
+    "config": {
+      "type": "object",
+      "title": "Send SMS",
+      "properties": {
+        "message": {
+          "type": "string",
+          "title": "Message",
+          "format": "multiline"
+        },
+        "to": {
+          "type": "string",
+          "title": "Phone Number"
+        }
+      },
+      "required": [
+        "to",
+        "message"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "smsSent": {
+          "type": "boolean"
+        }
+      }
+    }
+  },
+  "actionSetVariables": {
+    "type": "action",
+    "subType": "actionSetVariables",
+    "label": "Set Variables",
+    "icon": "Variable",
+    "description": "Set workflow variables",
+    "category": "Data Operations",
+    "config": {
+      "type": "object",
+      "title": "Set Variables"
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "actionUpdateEntityRecord": {
+    "type": "action",
+    "subType": "actionUpdateEntityRecord",
+    "label": "Update Entity Record",
+    "icon": "FileEdit",
+    "description": "Update an existing entity record",
+    "category": "Data Operations",
+    "config": {
+      "type": "object",
+      "title": "Update Entity Record",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "fields": {
+          "type": "object",
+          "title": "Field Updates"
+        },
+        "recordIdExpr": {
+          "type": "string",
+          "title": "Record ID Expression"
+        }
+      },
+      "required": [
+        "entityName",
+        "recordIdExpr"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "updated": {
+          "type": "boolean"
+        }
+      }
+    }
+  },
+  "agentChat": {
+    "type": "agent",
+    "subType": "agentChat",
+    "label": "Chat",
+    "icon": "MessageSquare",
+    "description": "AI chat interaction",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "Chat",
+      "properties": {
+        "maxTokens": {
+          "type": "integer",
+          "title": "Max Tokens",
+          "minimum": 1,
+          "maximum": 4096
+        },
+        "model": {
+          "type": "string",
+          "title": "Model",
+          "enum": [
+            "gpt-4",
+            "gpt-4-turbo",
+            "gpt-3.5-turbo",
+            "claude-3-opus",
+            "claude-3-sonnet"
+          ],
+          "x-enumLabels": [
+            "GPT-4",
+            "GPT-4 Turbo",
+            "GPT-3.5 Turbo",
+            "Claude 3 Opus",
+            "Claude 3 Sonnet"
+          ]
+        },
+        "systemPrompt": {
+          "type": "string",
+          "title": "System Prompt",
+          "format": "multiline"
+        },
+        "temperature": {
+          "type": "number",
+          "title": "Temperature",
+          "minimum": 0,
+          "maximum": 2
+        }
+      },
+      "required": [
+        "systemPrompt",
+        "model"
+      ]
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "message": {
+          "type": "string"
+        }
+      }
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "message": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "agentCustomResponse": {
+    "type": "agent",
+    "subType": "agentCustomResponse",
+    "label": "Custom Response",
+    "icon": "MessageCircle",
+    "description": "Send a custom response message",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "Custom Response",
+      "properties": {
+        "message": {
+          "type": "string",
+          "title": "Response Message",
+          "format": "multiline"
+        }
+      },
+      "required": [
+        "message"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "agentIntentDetector": {
+    "type": "agent",
+    "subType": "agentIntentDetector",
+    "label": "Intent Detector",
+    "icon": "Target",
+    "description": "Detect user intent from message",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "Intent Detector",
+      "properties": {
+        "intents": {
+          "type": "array",
+          "title": "Intents",
+          "items": {
+            "type": "object",
+            "properties": {
+              "description": {
+                "type": "string",
+                "title": "Description"
+              },
+              "id": {
+                "type": "string",
+                "title": "ID"
+              },
+              "name": {
+                "type": "string",
+                "title": "Name"
+              },
+              "nodeId": {
+                "type": "string",
+                "title": "Target Node ID"
+              }
+            }
+          }
+        }
+      },
+      "required": [
+        "intents"
+      ]
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "message": {
+          "type": "string"
+        }
+      }
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "confidence": {
+          "type": "number"
+        },
+        "intent": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "agentKnowledgeGraph": {
+    "type": "agent",
+    "subType": "agentKnowledgeGraph",
+    "label": "Knowledge Graph",
+    "icon": "Network",
+    "description": "Query knowledge graph for information",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "Knowledge Graph",
+      "properties": {
+        "fields": {
+          "type": "array",
+          "title": "Fields",
+          "items": {
+            "type": "object"
+          }
+        },
+        "label": {
+          "type": "string",
+          "title": "Label"
+        }
+      },
+      "required": [
+        "label"
+      ]
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "query": {
+          "type": "string"
+        }
+      }
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "kg_response": {
+          "type": "array",
+          "items": {
+            "type": "object"
+          }
+        }
+      }
+    }
+  },
+  "agentOpenTicket": {
+    "type": "agent",
+    "subType": "agentOpenTicket",
+    "label": "Open Ticket",
+    "icon": "Ticket",
+    "description": "Create a support ticket",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "Open Ticket",
+      "properties": {
+        "priority": {
+          "type": "string",
+          "title": "Priority",
+          "enum": [
+            "low",
+            "medium",
+            "high",
+            "urgent"
+          ]
+        },
+        "ticketType": {
+          "type": "string",
+          "title": "Ticket Type"
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "ticketId": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "agentStructuredOutput": {
+    "type": "agent",
+    "subType": "agentStructuredOutput",
+    "label": "Structured Output",
+    "icon": "Brain",
+    "description": "AI-powered structured data extraction",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "Structured Output",
+      "properties": {
+        "inputTemplate": {
+          "type": "string",
+          "title": "Input Template",
+          "format": "multiline"
+        },
+        "instructions": {
+          "type": "string",
+          "title": "Instructions",
+          "format": "multiline"
+        },
+        "model": {
+          "type": "string",
+          "title": "Model"
+        },
+        "systemPrompt": {
+          "type": "string",
+          "title": "System Prompt",
+          "format": "multiline"
+        },
+        "temperature": {
+          "type": "number",
+          "title": "Temperature",
+          "minimum": 0,
+          "maximum": 2
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "agentTransferToHuman": {
+    "type": "agent",
+    "subType": "agentTransferToHuman",
+    "label": "Transfer to Human",
+    "icon": "UserCheck",
+    "description": "Transfer conversation to human agent",
+    "category": "AI & Automation",
+    "config": {
+      "type": "object",
+      "title": "Transfer to Human",
+      "properties": {
+        "message": {
+          "type": "string",
+          "title": "Transfer Message",
+          "format": "multiline"
+        },
+        "queueId": {
+          "type": "string",
+          "title": "Queue ID"
+        }
+      },
+      "required": [
+        "message",
+        "queueId"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "delay": {
+    "type": "delay",
+    "subType": "delay",
+    "label": "Delay",
+    "icon": "Clock",
+    "description": "Wait for a specified duration",
+    "category": "Time & Scheduling",
+    "config": {
+      "type": "object",
+      "title": "Delay",
+      "properties": {
+        "duration": {
+          "type": "integer",
+          "title": "Duration",
+          "minimum": 1
+        },
+        "unit": {
+          "type": "string",
+          "title": "Unit",
+          "enum": [
+            "seconds",
+            "minutes",
+            "hours",
+            "days"
+          ],
+          "x-enumLabels": [
+            "Seconds",
+            "Minutes",
+            "Hours",
+            "Days"
+          ]
+        }
+      },
+      "required": [
+        "duration",
+        "unit"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "humanActionApproval": {
+    "type": "humanAction",
+    "subType": "humanActionApproval",
+    "label": "Approval",
+    "icon": "CheckCircle",
+    "description": "Request human approval",
+    "category": "User Interaction",
+    "config": {
+      "type": "object",
+      "title": "Approval",
+      "properties": {
+        "allowEdit": {
+          "type": "boolean",
+          "title": "Allow Edit"
+        },
+        "assignTo": {
+          "type": "string",
+          "title": "Assign To"
+        },
+        "dueInHours": {
+          "type": "integer",
+          "title": "Due In (Hours)",
+          "minimum": 1
+        },
+        "instructions": {
+          "type": "string",
+          "title": "Instructions",
+          "format": "multiline"
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "decision": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "humanActionAssignment": {
+    "type": "humanAction",
+    "subType": "humanActionAssignment",
+    "label": "Task Assignment",
+    "icon": "UserPlus",
+    "description": "Assign a task to a user",
+    "category": "User Interaction",
+    "config": {
+      "type": "object",
+      "title": "Task Assignment",
+      "properties": {
+        "assignTo": {
+          "type": "string",
+          "title": "Assign To"
+        },
+        "dueInHours": {
+          "type": "integer",
+          "title": "Due In (Hours)",
+          "minimum": 1
+        },
+        "priority": {
+          "type": "string",
+          "title": "Priority",
+          "enum": [
+            "low",
+            "medium",
+            "high",
+            "urgent"
+          ],
+          "x-enumLabels": [
+            "Low",
+            "Medium",
+            "High",
+            "Urgent"
+          ]
+        },
+        "taskDescription": {
+          "type": "string",
+          "title": "Task Description",
+          "format": "multiline"
+        },
+        "taskTitle": {
+          "type": "string",
+          "title": "Task Title"
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "humanActionDataEntry": {
+    "type": "humanAction",
+    "subType": "humanActionDataEntry",
+    "label": "Data Entry",
+    "icon": "FormInput",
+    "description": "Request human data entry",
+    "category": "User Interaction",
+    "config": {
+      "type": "object",
+      "title": "Data Entry",
+      "properties": {
+        "assignTo": {
+          "type": "string",
+          "title": "Assign To"
+        },
+        "formSchema": {
+          "type": "object",
+          "title": "Form Schema"
+        },
+        "instructions": {
+          "type": "string",
+          "title": "Instructions",
+          "format": "multiline"
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "humanActionReview": {
+    "type": "humanAction",
+    "subType": "humanActionReview",
+    "label": "Review",
+    "icon": "Eye",
+    "description": "Request human review",
+    "category": "User Interaction",
+    "config": {
+      "type": "object",
+      "title": "Review",
+      "properties": {
+        "assignTo": {
+          "type": "string",
+          "title": "Assign To"
+        },
+        "dueInHours": {
+          "type": "integer",
+          "title": "Due In (Hours)",
+          "minimum": 1
+        },
+        "editableFields": {
+          "type": "array",
+          "title": "Editable Fields",
+          "items": {
+            "type": "string"
+          }
+        },
+        "instructions": {
+          "type": "string",
+          "title": "Instructions",
+          "format": "multiline"
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "decision": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "integrationCreateEvent": {
+    "type": "integration",
+    "subType": "integrationCreateEvent",
+    "label": "Create Calendar Event",
+    "icon": "CalendarPlus",
+    "description": "Create event in user's calendar",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "Create Calendar Event",
+      "properties": {
+        "attendees": {
+          "type": "string",
+          "title": "Attendees",
+          "description": "Comma-separated email addresses"
+        },
+        "description": {
+          "type": "string",
+          "title": "Description",
+          "format": "multiline"
+        },
+        "endTime": {
+          "type": "string",
+          "title": "End Time",
+          "format": "date-time"
+        },
+        "location": {
+          "type": "string",
+          "title": "Location"
+        },
+        "sendInvites": {
+          "type": "boolean",
+          "title": "Send Calendar Invites",
+          "default": true
+        },
+        "startTime": {
+          "type": "string",
+          "title": "Start Time",
+          "format": "date-time"
+        },
+        "title": {
+          "type": "string",
+          "title": "Title"
+        }
+      },
+      "required": [
+        "title",
+        "startTime",
+        "endTime"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "created": {
+          "type": "boolean",
+          "title": "Created"
+        },
+        "eventId": {
+          "type": "string",
+          "title": "Event ID"
+        },
+        "eventUrl": {
+          "type": "string",
+          "title": "Event URL"
+        }
+      }
+    }
+  },
+  "integrationGetDriveFile": {
+    "type": "integration",
+    "subType": "integrationGetDriveFile",
+    "label": "Get Drive File",
+    "icon": "File",
+    "description": "Get details of a specific file",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "Get Drive File",
+      "properties": {
+        "fileId": {
+          "type": "string",
+          "title": "File ID"
+        }
+      },
+      "required": [
+        "fileId"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "file": {
+          "type": "object",
+          "properties": {
+            "downloadUrl": {
+              "type": "string",
+              "title": "Download URL"
+            },
+            "id": {
+              "type": "string",
+              "title": "File ID"
+            },
+            "mimeType": {
+              "type": "string",
+              "title": "MIME Type"
+            },
+            "name": {
+              "type": "string",
+              "title": "Name"
+            },
+            "size": {
+              "type": "integer",
+              "title": "Size (bytes)"
+            },
+            "webLink": {
+              "type": "string",
+              "title": "Web Link"
+            }
+          }
+        }
+      }
+    }
+  },
+  "integrationSearchCalendar": {
+    "type": "integration",
+    "subType": "integrationSearchCalendar",
+    "label": "Search Calendar",
+    "icon": "CalendarSearch",
+    "description": "Search calendar events",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "Search Calendar",
+      "properties": {
+        "maxResults": {
+          "type": "integer",
+          "title": "Max Results",
+          "default": 20,
+          "minimum": 1,
+          "maximum": 100
+        },
+        "query": {
+          "type": "string",
+          "title": "Search Query",
+          "description": "Search in event titles and descriptions"
+        },
+        "timeMax": {
+          "type": "string",
+          "title": "End Date",
+          "description": "Search events before this date",
+          "format": "date-time"
+        },
+        "timeMin": {
+          "type": "string",
+          "title": "Start Date",
+          "description": "Search events after this date",
+          "format": "date-time"
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "events": {
+          "type": "array",
+          "title": "Events",
+          "items": {
+            "type": "object"
+          }
+        },
+        "total": {
+          "type": "integer",
+          "title": "Total"
+        }
+      }
+    }
+  },
+  "integrationSearchDrive": {
+    "type": "integration",
+    "subType": "integrationSearchDrive",
+    "label": "Search Drive",
+    "icon": "FolderSearch",
+    "description": "Search files in user's Drive",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "Search Drive",
+      "properties": {
+        "folderId": {
+          "type": "string",
+          "title": "Folder ID",
+          "description": "Search in specific folder"
+        },
+        "maxResults": {
+          "type": "integer",
+          "title": "Max Results",
+          "default": 20,
+          "minimum": 1,
+          "maximum": 100
+        },
+        "mimeType": {
+          "type": "string",
+          "title": "File Type",
+          "enum": [
+            "",
+            "document",
+            "spreadsheet",
+            "presentation",
+            "pdf",
+            "image",
+            "folder"
+          ],
+          "x-enumLabels": [
+            "Any",
+            "Documents",
+            "Spreadsheets",
+            "Presentations",
+            "PDFs",
+            "Images",
+            "Folders"
+          ]
+        },
+        "query": {
+          "type": "string",
+          "title": "Search Query",
+          "description": "Search in file names and content"
+        }
+      },
+      "required": [
+        "query"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "files": {
+          "type": "array",
+          "title": "Files",
+          "items": {
+            "type": "object"
+          }
+        },
+        "total": {
+          "type": "integer",
+          "title": "Total"
+        }
+      }
+    }
+  },
+  "integrationSearchEmails": {
+    "type": "integration",
+    "subType": "integrationSearchEmails",
+    "label": "Search Emails",
+    "icon": "MailSearch",
+    "description": "Search user's emails",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "Search Emails",
+      "properties": {
+        "dateRange": {
+          "type": "string",
+          "title": "Date Range",
+          "enum": [
+            "1d",
+            "7d",
+            "30d",
+            "90d",
+            "all"
+          ],
+          "x-enumLabels": [
+            "Last 24 hours",
+            "Last 7 days",
+            "Last 30 days",
+            "Last 90 days",
+            "All time"
+          ]
+        },
+        "maxResults": {
+          "type": "integer",
+          "title": "Max Results",
+          "default": 20,
+          "minimum": 1,
+          "maximum": 100
+        },
+        "query": {
+          "type": "string",
+          "title": "Search Query",
+          "description": "Gmail/Outlook search query"
+        }
+      },
+      "required": [
+        "query"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "emails": {
+          "type": "array",
+          "title": "Emails",
+          "items": {
+            "type": "object"
+          }
+        },
+        "total": {
+          "type": "integer",
+          "title": "Total"
+        }
+      }
+    }
+  },
+  "integrationSendEmail": {
+    "type": "integration",
+    "subType": "integrationSendEmail",
+    "label": "Send Email",
+    "icon": "Send",
+    "description": "Send email via user's connected account",
+    "category": "Integration",
+    "config": {
+      "type": "object",
+      "title": "Send Email",
+      "properties": {
+        "body": {
+          "type": "string",
+          "title": "Body",
+          "format": "multiline"
+        },
+        "bodyType": {
+          "type": "string",
+          "title": "Body Type",
+          "default": "text",
+          "enum": [
+            "text",
+            "html"
+          ],
+          "x-enumLabels": [
+            "Plain Text",
+            "HTML"
+          ]
+        },
+        "cc": {
+          "type": "string",
+          "title": "CC"
+        },
+        "replyToMessageId": {
+          "type": "string",
+          "title": "Reply To Message ID",
+          "description": "Optional: message ID to reply to"
+        },
+        "subject": {
+          "type": "string",
+          "title": "Subject"
+        },
+        "to": {
+          "type": "string",
+          "title": "To"
+        }
+      },
+      "required": [
+        "to",
+        "subject",
+        "body"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "messageId": {
+          "type": "string",
+          "title": "Message ID"
+        },
+        "sent": {
+          "type": "boolean",
+          "title": "Sent"
+        }
+      }
+    }
+  },
+  "logicFor": {
+    "type": "logic",
+    "subType": "logicFor",
+    "label": "Loop",
+    "icon": "Repeat",
+    "description": "Iterate over a collection",
+    "category": "Flow Control",
+    "config": {
+      "type": "object",
+      "title": "Loop",
+      "properties": {
+        "collection": {
+          "type": "string",
+          "title": "Collection Expression"
+        },
+        "indexVariable": {
+          "type": "string",
+          "title": "Index Variable Name"
+        },
+        "itemVariable": {
+          "type": "string",
+          "title": "Item Variable Name"
+        },
+        "maxIterations": {
+          "type": "integer",
+          "title": "Max Iterations",
+          "minimum": 1,
+          "maximum": 1e4
+        }
+      },
+      "required": [
+        "collection"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "logicIf": {
+    "type": "logic",
+    "subType": "logicIf",
+    "label": "If Condition",
+    "icon": "GitBranch",
+    "description": "Conditional branching based on variables",
+    "category": "Flow Control",
+    "config": {
+      "type": "object",
+      "title": "If Condition Configuration",
+      "properties": {
+        "conditions": {
+          "type": "array",
+          "title": "Conditions",
+          "description": "Define conditions to evaluate against workflow variables",
+          "items": {
+            "type": "object",
+            "properties": {
+              "field": {
+                "type": "string",
+                "title": "Variable",
+                "description": "Variable path (e.g., emailSent, user.role)"
+              },
+              "operator": {
+                "type": "string",
+                "title": "Operator",
+                "enum": [
+                  "eq",
+                  "neq",
+                  "gt",
+                  "gte",
+                  "lt",
+                  "lte",
+                  "contains",
+                  "startsWith",
+                  "endsWith",
+                  "isEmpty",
+                  "isNotEmpty"
+                ]
+              },
+              "value": {
+                "type": "string",
+                "title": "Value",
+                "description": "Value to compare against"
+              }
+            },
+            "required": [
+              "field",
+              "operator"
+            ]
+          }
+        },
+        "defaultPath": {
+          "type": "string",
+          "title": "Default Path ID",
+          "description": "Path to use if no condition matches"
+        },
+        "expression": {
+          "type": "string",
+          "title": "Advanced Expression",
+          "description": "JavaScript expression for complex conditions (e.g., amount > 1000 && status === 'approved')",
+          "format": "multiline"
+        },
+        "logic": {
+          "type": "string",
+          "title": "Logic",
+          "description": "How to combine multiple conditions",
+          "default": "and",
+          "enum": [
+            "and",
+            "or"
+          ]
+        },
+        "paths": {
+          "type": "array",
+          "title": "Paths",
+          "description": "Define target nodes for true/false outcomes",
+          "items": {
+            "type": "object",
+            "properties": {
+              "condition": {
+                "type": "string",
+                "title": "Condition",
+                "enum": [
+                  "true",
+                  "false"
+                ]
+              },
+              "id": {
+                "type": "string",
+                "title": "Path ID"
+              },
+              "nodeId": {
+                "type": "string",
+                "title": "Target Node ID"
+              }
+            },
+            "required": [
+              "id",
+              "condition"
+            ]
+          }
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "conditionResult": {
+          "type": "boolean"
+        },
+        "pathTaken": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "logicSwitch": {
+    "type": "logic",
+    "subType": "logicSwitch",
+    "label": "Switch",
+    "icon": "GitMerge",
+    "description": "Multi-way branching based on value",
+    "category": "Flow Control",
+    "config": {
+      "type": "object",
+      "title": "Switch",
+      "properties": {
+        "cases": {
+          "type": "array",
+          "title": "Cases",
+          "items": {
+            "type": "object",
+            "properties": {
+              "nodeId": {
+                "type": "string",
+                "title": "Target Node ID"
+              },
+              "value": {
+                "type": "string",
+                "title": "Value"
+              }
+            }
+          }
+        },
+        "expression": {
+          "type": "string",
+          "title": "Switch Expression"
+        }
+      },
+      "required": [
+        "expression"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "triggerCalendarEvent": {
+    "type": "trigger",
+    "subType": "triggerCalendarEvent",
+    "label": "Calendar Event",
+    "icon": "CalendarClock",
+    "description": "Trigger before or when calendar events occur",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Calendar Trigger",
+      "properties": {
+        "leadTime": {
+          "type": "integer",
+          "title": "Minutes Before",
+          "description": "For reminder triggers",
+          "default": 30,
+          "minimum": 5,
+          "maximum": 1440
+        },
+        "provider": {
+          "type": "string",
+          "title": "Provider",
+          "enum": [
+            "google",
+            "microsoft"
+          ],
+          "x-enumLabels": [
+            "Google Calendar",
+            "Outlook Calendar"
+          ]
+        },
+        "triggerType": {
+          "type": "string",
+          "title": "Trigger When",
+          "enum": [
+            "reminder",
+            "event_start",
+            "event_created"
+          ],
+          "x-enumLabels": [
+            "Before Event (Reminder)",
+            "Event Starts",
+            "Event Created"
+          ]
+        }
+      },
+      "required": [
+        "provider",
+        "triggerType"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "event": {
+          "type": "object",
+          "properties": {
+            "attendees": {
+              "type": "array",
+              "title": "Attendees",
+              "items": {
+                "type": "string"
+              }
+            },
+            "description": {
+              "type": "string",
+              "title": "Description"
+            },
+            "endTime": {
+              "type": "string",
+              "title": "End Time",
+              "format": "date-time"
+            },
+            "id": {
+              "type": "string",
+              "title": "Event ID"
+            },
+            "location": {
+              "type": "string",
+              "title": "Location"
+            },
+            "startTime": {
+              "type": "string",
+              "title": "Start Time",
+              "format": "date-time"
+            },
+            "title": {
+              "type": "string",
+              "title": "Title"
+            }
+          }
+        }
+      }
+    }
+  },
+  "triggerDriveFileChanged": {
+    "type": "trigger",
+    "subType": "triggerDriveFileChanged",
+    "label": "File Changed",
+    "icon": "FolderSync",
+    "description": "Trigger when files are added or modified in Drive",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Drive Trigger",
+      "properties": {
+        "changeType": {
+          "type": "string",
+          "title": "Change Type",
+          "enum": [
+            "created",
+            "modified",
+            "any"
+          ],
+          "x-enumLabels": [
+            "File Created",
+            "File Modified",
+            "Any Change"
+          ]
+        },
+        "fileTypes": {
+          "type": "array",
+          "title": "File Types",
+          "description": "Filter by extension (e.g., pdf, docx)",
+          "items": {
+            "type": "string"
+          }
+        },
+        "folderId": {
+          "type": "string",
+          "title": "Folder ID",
+          "description": "Watch specific folder (leave empty for all)"
+        },
+        "pollInterval": {
+          "type": "integer",
+          "title": "Poll Interval (minutes)",
+          "default": 10,
+          "minimum": 5
+        },
+        "provider": {
+          "type": "string",
+          "title": "Provider",
+          "enum": [
+            "google",
+            "microsoft"
+          ],
+          "x-enumLabels": [
+            "Google Drive",
+            "OneDrive"
+          ]
+        }
+      },
+      "required": [
+        "provider",
+        "changeType"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "file": {
+          "type": "object",
+          "properties": {
+            "createdAt": {
+              "type": "string",
+              "title": "Created At",
+              "format": "date-time"
+            },
+            "id": {
+              "type": "string",
+              "title": "File ID"
+            },
+            "mimeType": {
+              "type": "string",
+              "title": "MIME Type"
+            },
+            "name": {
+              "type": "string",
+              "title": "Name"
+            },
+            "size": {
+              "type": "integer",
+              "title": "Size (bytes)"
+            },
+            "webLink": {
+              "type": "string",
+              "title": "Web Link"
+            }
+          }
+        }
+      }
+    }
+  },
+  "triggerEmailReceived": {
+    "type": "trigger",
+    "subType": "triggerEmailReceived",
+    "label": "Email Received",
+    "icon": "Mail",
+    "description": "Trigger when a new email matches filters",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Email Trigger",
+      "properties": {
+        "fromFilter": {
+          "type": "string",
+          "title": "From (contains)",
+          "description": "Filter by sender email or name"
+        },
+        "hasAttachment": {
+          "type": "boolean",
+          "title": "Has Attachment"
+        },
+        "isUnread": {
+          "type": "boolean",
+          "title": "Unread Only",
+          "default": true
+        },
+        "labelFilter": {
+          "type": "string",
+          "title": "Label/Folder",
+          "description": "Gmail label or Outlook folder"
+        },
+        "pollInterval": {
+          "type": "integer",
+          "title": "Poll Interval (minutes)",
+          "default": 5,
+          "minimum": 1,
+          "maximum": 60
+        },
+        "provider": {
+          "type": "string",
+          "title": "Provider",
+          "enum": [
+            "google",
+            "microsoft"
+          ],
+          "x-enumLabels": [
+            "Gmail",
+            "Outlook"
+          ]
+        },
+        "subjectFilter": {
+          "type": "string",
+          "title": "Subject (contains)"
+        }
+      },
+      "required": [
+        "provider"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "email": {
+          "type": "object",
+          "properties": {
+            "body": {
+              "type": "string",
+              "title": "Body"
+            },
+            "date": {
+              "type": "string",
+              "title": "Date",
+              "format": "date-time"
+            },
+            "from": {
+              "type": "string",
+              "title": "From"
+            },
+            "id": {
+              "type": "string",
+              "title": "Email ID"
+            },
+            "snippet": {
+              "type": "string",
+              "title": "Snippet"
+            },
+            "subject": {
+              "type": "string",
+              "title": "Subject"
+            },
+            "to": {
+              "type": "string",
+              "title": "To"
+            }
+          }
+        }
+      }
+    }
+  },
+  "triggerEntityRecordCreated": {
+    "type": "trigger",
+    "subType": "triggerEntityRecordCreated",
+    "label": "Entity Record Created",
+    "icon": "Plus",
+    "description": "Triggers when a new entity record is created",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Entity Record Created",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "filters": {
+          "type": "object",
+          "title": "Filters"
+        }
+      },
+      "required": [
+        "entityName"
+      ]
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "entityName": {
+          "type": "string"
+        },
+        "entityRecordId": {
+          "type": "string"
+        }
+      }
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "entityRecordId": {
+          "type": "string",
+          "title": "Record ID"
+        },
+        "record": {
+          "type": "object",
+          "title": "Entity Record",
+          "description": "The created entity record (fields vary by entity type)"
+        }
+      }
+    }
+  },
+  "triggerEntityRecordDeleted": {
+    "type": "trigger",
+    "subType": "triggerEntityRecordDeleted",
+    "label": "Entity Record Deleted",
+    "icon": "Trash",
+    "description": "Triggers when an entity record is deleted",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Entity Record Deleted",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        }
+      },
+      "required": [
+        "entityName"
+      ]
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "entityName": {
+          "type": "string"
+        },
+        "entityRecordId": {
+          "type": "string"
+        }
+      }
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "entityRecordId": {
+          "type": "string",
+          "title": "Record ID"
+        },
+        "record": {
+          "type": "object",
+          "title": "Entity Record",
+          "description": "The deleted entity record (fields vary by entity type)"
+        }
+      }
+    }
+  },
+  "triggerEntityRecordUpdated": {
+    "type": "trigger",
+    "subType": "triggerEntityRecordUpdated",
+    "label": "Entity Record Updated",
+    "icon": "Pencil",
+    "description": "Triggers when an entity record is updated",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Entity Record Updated",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "filters": {
+          "type": "object",
+          "title": "Filters"
+        },
+        "watchFields": {
+          "type": "array",
+          "title": "Watch Fields",
+          "items": {
+            "type": "string"
+          }
+        }
+      },
+      "required": [
+        "entityName"
+      ]
+    },
+    "input": {
+      "type": "object",
+      "properties": {
+        "entityName": {
+          "type": "string"
+        },
+        "entityRecordId": {
+          "type": "string"
+        }
+      }
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "entityName": {
+          "type": "string",
+          "title": "Entity Name"
+        },
+        "entityRecordId": {
+          "type": "string",
+          "title": "Record ID"
+        },
+        "record": {
+          "type": "object",
+          "title": "Entity Record",
+          "description": "The updated entity record (fields vary by entity type)"
+        }
+      }
+    }
+  },
+  "triggerEscalation": {
+    "type": "trigger",
+    "subType": "triggerEscalation",
+    "label": "Escalation",
+    "icon": "ArrowUpRight",
+    "description": "Triggers when an escalation occurs",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Escalation",
+      "properties": {
+        "escalationLevel": {
+          "type": "integer",
+          "title": "Escalation Level",
+          "minimum": 1
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "triggerSLABreach": {
+    "type": "trigger",
+    "subType": "triggerSLABreach",
+    "label": "SLA Breach",
+    "icon": "TriangleAlert",
+    "description": "Triggers when an SLA breach occurs",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "SLA Breach",
+      "properties": {
+        "policyId": {
+          "type": "string",
+          "title": "SLA Policy ID"
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "triggerSLAWarning": {
+    "type": "trigger",
+    "subType": "triggerSLAWarning",
+    "label": "SLA Warning",
+    "icon": "Timer",
+    "description": "Triggers when an SLA warning occurs",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "SLA Warning",
+      "properties": {
+        "policyId": {
+          "type": "string",
+          "title": "SLA Policy ID"
+        },
+        "warningThreshold": {
+          "type": "number",
+          "title": "Warning Threshold (%)",
+          "minimum": 0,
+          "maximum": 100
+        }
+      }
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "triggerSchedule": {
+    "type": "trigger",
+    "subType": "triggerSchedule",
+    "label": "Schedule",
+    "icon": "Calendar",
+    "description": "Trigger workflow on a schedule (cron expression)",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Schedule Trigger",
+      "properties": {
+        "description": {
+          "type": "string",
+          "title": "Description"
+        },
+        "schedule": {
+          "type": "string",
+          "title": "Cron Expression",
+          "description": "e.g., '0 9 * * MON-FRI' for weekdays at 9am"
+        },
+        "timezone": {
+          "type": "string",
+          "title": "Timezone",
+          "default": "UTC",
+          "enum": [
+            "UTC",
+            "America/New_York",
+            "America/Chicago",
+            "America/Denver",
+            "America/Los_Angeles",
+            "Europe/London",
+            "Europe/Paris",
+            "Asia/Tokyo"
+          ],
+          "x-enumLabels": [
+            "UTC",
+            "Eastern Time",
+            "Central Time",
+            "Mountain Time",
+            "Pacific Time",
+            "London",
+            "Paris",
+            "Tokyo"
+          ]
+        }
+      },
+      "required": [
+        "schedule"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "schedule": {
+          "type": "string",
+          "title": "Schedule"
+        },
+        "triggeredAt": {
+          "type": "string",
+          "title": "Triggered At",
+          "format": "date-time"
+        }
+      }
+    }
+  },
+  "triggerStart": {
+    "type": "trigger",
+    "subType": "triggerStart",
+    "label": "Start",
+    "icon": "Play",
+    "description": "Workflow entry point - receives input and sets variables",
+    "category": "Triggers",
+    "config": {
+      "type": "object"
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  },
+  "triggerWebhookReceived": {
+    "type": "trigger",
+    "subType": "triggerWebhookReceived",
+    "label": "Webhook",
+    "icon": "Webhook",
+    "description": "Triggers when a webhook is received",
+    "category": "Triggers",
+    "config": {
+      "type": "object",
+      "title": "Webhook Trigger",
+      "properties": {
+        "method": {
+          "type": "string",
+          "title": "HTTP Method",
+          "enum": [
+            "POST",
+            "GET",
+            "PUT"
+          ]
+        },
+        "secret": {
+          "type": "string",
+          "title": "Secret",
+          "format": "password"
+        },
+        "webhookPath": {
+          "type": "string",
+          "title": "Webhook Path"
+        }
+      },
+      "required": [
+        "webhookPath"
+      ]
+    },
+    "input": {
+      "type": "object"
+    },
+    "output": {
+      "type": "object"
+    }
+  }
+};
+var nodeSchemas = Object.fromEntries(
+  Object.entries(nodeDefinitions).map(([key, def]) => [key, def.config])
+);
+var TriggerNodeSubTypes = {
+  "triggerCalendarEvent": {
+    "value": "triggerCalendarEvent",
+    "label": "Calendar Event",
+    "icon": "CalendarClock",
+    "description": "Trigger before or when calendar events occur"
+  },
+  "triggerDriveFileChanged": {
+    "value": "triggerDriveFileChanged",
+    "label": "File Changed",
+    "icon": "FolderSync",
+    "description": "Trigger when files are added or modified in Drive"
+  },
+  "triggerEmailReceived": {
+    "value": "triggerEmailReceived",
+    "label": "Email Received",
+    "icon": "Mail",
+    "description": "Trigger when a new email matches filters"
+  },
+  "triggerEntityRecordCreated": {
+    "value": "triggerEntityRecordCreated",
+    "label": "Entity Record Created",
+    "icon": "Plus",
+    "description": "Triggers when a new entity record is created"
+  },
+  "triggerEntityRecordDeleted": {
+    "value": "triggerEntityRecordDeleted",
+    "label": "Entity Record Deleted",
+    "icon": "Trash",
+    "description": "Triggers when an entity record is deleted"
+  },
+  "triggerEntityRecordUpdated": {
+    "value": "triggerEntityRecordUpdated",
+    "label": "Entity Record Updated",
+    "icon": "Pencil",
+    "description": "Triggers when an entity record is updated"
+  },
+  "triggerEscalation": {
+    "value": "triggerEscalation",
+    "label": "Escalation",
+    "icon": "ArrowUpRight",
+    "description": "Triggers when an escalation occurs"
+  },
+  "triggerSLABreach": {
+    "value": "triggerSLABreach",
+    "label": "SLA Breach",
+    "icon": "TriangleAlert",
+    "description": "Triggers when an SLA breach occurs"
+  },
+  "triggerSLAWarning": {
+    "value": "triggerSLAWarning",
+    "label": "SLA Warning",
+    "icon": "Timer",
+    "description": "Triggers when an SLA warning occurs"
+  },
+  "triggerSchedule": {
+    "value": "triggerSchedule",
+    "label": "Schedule",
+    "icon": "Calendar",
+    "description": "Trigger workflow on a schedule (cron expression)"
+  },
+  "triggerStart": {
+    "value": "triggerStart",
+    "label": "Start",
+    "icon": "Play",
+    "description": "Workflow entry point - receives input and sets variables"
+  },
+  "triggerWebhookReceived": {
+    "value": "triggerWebhookReceived",
+    "label": "Webhook",
+    "icon": "Webhook",
+    "description": "Triggers when a webhook is received"
+  }
+};
+var HumanActionNodeSubTypes = {
+  "humanActionApproval": {
+    "value": "humanActionApproval",
+    "label": "Approval",
+    "icon": "CheckCircle",
+    "description": "Request human approval"
+  },
+  "humanActionAssignment": {
+    "value": "humanActionAssignment",
+    "label": "Task Assignment",
+    "icon": "UserPlus",
+    "description": "Assign a task to a user"
+  },
+  "humanActionDataEntry": {
+    "value": "humanActionDataEntry",
+    "label": "Data Entry",
+    "icon": "FormInput",
+    "description": "Request human data entry"
+  },
+  "humanActionReview": {
+    "value": "humanActionReview",
+    "label": "Review",
+    "icon": "Eye",
+    "description": "Request human review"
+  }
+};
+var AgentNodeSubTypes = {
+  "actionAIClassify": {
+    "value": "actionAIClassify",
+    "label": "AI Classify",
+    "icon": "Tags",
+    "description": "Classify content into categories using AI"
+  },
+  "actionAIExtractData": {
+    "value": "actionAIExtractData",
+    "label": "AI Extract Data",
+    "icon": "FileSearch",
+    "description": "Extract structured data from unstructured content"
+  },
+  "actionAISummarize": {
+    "value": "actionAISummarize",
+    "label": "AI Summarize",
+    "icon": "FileText",
+    "description": "Summarize text content using AI"
+  },
+  "agentChat": {
+    "value": "agentChat",
+    "label": "Chat",
+    "icon": "MessageSquare",
+    "description": "AI chat interaction"
+  },
+  "agentCustomResponse": {
+    "value": "agentCustomResponse",
+    "label": "Custom Response",
+    "icon": "MessageCircle",
+    "description": "Send a custom response message"
+  },
+  "agentIntentDetector": {
+    "value": "agentIntentDetector",
+    "label": "Intent Detector",
+    "icon": "Target",
+    "description": "Detect user intent from message"
+  },
+  "agentKnowledgeGraph": {
+    "value": "agentKnowledgeGraph",
+    "label": "Knowledge Graph",
+    "icon": "Network",
+    "description": "Query knowledge graph for information"
+  },
+  "agentOpenTicket": {
+    "value": "agentOpenTicket",
+    "label": "Open Ticket",
+    "icon": "Ticket",
+    "description": "Create a support ticket"
+  },
+  "agentStructuredOutput": {
+    "value": "agentStructuredOutput",
+    "label": "Structured Output",
+    "icon": "Brain",
+    "description": "AI-powered structured data extraction"
+  },
+  "agentTransferToHuman": {
+    "value": "agentTransferToHuman",
+    "label": "Transfer to Human",
+    "icon": "UserCheck",
+    "description": "Transfer conversation to human agent"
+  }
+};
+var ActionNodeSubTypes = {
+  "actionApiCall": {
+    "value": "actionApiCall",
+    "label": "API Call",
+    "icon": "Globe",
+    "description": "Make HTTP API requests"
+  },
+  "actionAssignSLAPolicy": {
+    "value": "actionAssignSLAPolicy",
+    "label": "Assign SLA Policy",
+    "icon": "Clock",
+    "description": "Assign an SLA policy to a record"
+  },
+  "actionCreateEntityRecord": {
+    "value": "actionCreateEntityRecord",
+    "label": "Create Entity Record",
+    "icon": "FilePlus",
+    "description": "Create a new entity record"
+  },
+  "actionDeleteEntityRecord": {
+    "value": "actionDeleteEntityRecord",
+    "label": "Delete Entity Record",
+    "icon": "FileX",
+    "description": "Delete an entity record"
+  },
+  "actionDocumentExtraction": {
+    "value": "actionDocumentExtraction",
+    "label": "Document Extraction",
+    "icon": "FileSearch",
+    "description": "Extract data from documents using AI"
+  },
+  "actionNatsRequest": {
+    "value": "actionNatsRequest",
+    "label": "NATS Request",
+    "icon": "Send",
+    "description": "Execute a NATS request-reply call with dynamic subject routing"
+  },
+  "actionQueryEntityRecords": {
+    "value": "actionQueryEntityRecords",
+    "label": "Query Entity Records",
+    "icon": "Search",
+    "description": "Query entity records with filters"
+  },
+  "actionSendEmail": {
+    "value": "actionSendEmail",
+    "label": "Send Email",
+    "icon": "Mail",
+    "description": "Send an email notification"
+  },
+  "actionSendSMS": {
+    "value": "actionSendSMS",
+    "label": "Send SMS",
+    "icon": "Smartphone",
+    "description": "Send an SMS message"
+  },
+  "actionSetVariables": {
+    "value": "actionSetVariables",
+    "label": "Set Variables",
+    "icon": "Variable",
+    "description": "Set workflow variables"
+  },
+  "actionUpdateEntityRecord": {
+    "value": "actionUpdateEntityRecord",
+    "label": "Update Entity Record",
+    "icon": "FileEdit",
+    "description": "Update an existing entity record"
+  }
+};
+var LogicNodeSubTypes = {
+  "logicFor": {
+    "value": "logicFor",
+    "label": "Loop",
+    "icon": "Repeat",
+    "description": "Iterate over a collection"
+  },
+  "logicIf": {
+    "value": "logicIf",
+    "label": "If Condition",
+    "icon": "GitBranch",
+    "description": "Conditional branching based on variables"
+  },
+  "logicSwitch": {
+    "value": "logicSwitch",
+    "label": "Switch",
+    "icon": "GitMerge",
+    "description": "Multi-way branching based on value"
+  }
+};
+var DelayNodeSubTypes = {
+  "delay": {
+    "value": "delay",
+    "label": "Delay",
+    "icon": "Clock",
+    "description": "Wait for a specified duration"
+  }
+};
+var ParallelNodeSubTypes = {};
+var DataNodeSubTypes = {};
+var TimerNodeSubTypes = {};
+var LoopNodeSubTypes = {};
+var AccountingNodeSubTypes = {};
+var WorkflowNodeTypes = {
+  trigger: { value: "trigger", label: "Trigger", category: "Triggers" },
+  humanAction: { value: "humanAction", label: "Human Action", category: "User Interaction" },
+  agent: { value: "agent", label: "Agent", category: "Automation" },
+  action: { value: "action", label: "Action", category: "Automation" },
+  logic: { value: "logic", label: "Logic", category: "Flow Control" },
+  data: { value: "data", label: "Data", category: "Data Processing" },
+  integration: { value: "integration", label: "Integration", category: "Integration" },
+  timer: { value: "timer", label: "Timer", category: "Time & Scheduling" },
+  loop: { value: "loop", label: "Loop", category: "Flow Control" },
+  parallel: { value: "parallel", label: "Parallel", category: "Flow Control" },
+  delay: { value: "delay", label: "Delay", category: "Flow Control" },
+  subflow: { value: "subflow", label: "Subflow", category: "Flow Control" },
+  custom: { value: "custom", label: "Custom", category: "Custom" },
+  documentExtraction: { value: "documentExtraction", label: "Document Extraction", category: "Data Processing" },
+  apiCall: { value: "apiCall", label: "API Call", category: "Integration" },
+  accounting: { value: "accounting", label: "Accounting", category: "Accounting" }
+};
+var WorkflowEdgeTypes = {
+  "compensation": {
+    "value": "compensation",
+    "label": "Compensation"
+  },
+  "conditional": {
+    "value": "conditional",
+    "label": "Conditional"
+  },
+  "default": {
+    "value": "default",
+    "label": "Default"
+  },
+  "error": {
+    "value": "error",
+    "label": "Error"
+  },
+  "loopBack": {
+    "value": "loopBack",
+    "label": "Loop Back"
+  },
+  "merge": {
+    "value": "merge",
+    "label": "Merge"
+  },
+  "normal": {
+    "value": "normal",
+    "label": "Normal"
+  },
+  "parallel": {
+    "value": "parallel",
+    "label": "Parallel"
+  },
+  "timeout": {
+    "value": "timeout",
+    "label": "Timeout"
+  }
+};
+var WorkflowTypes = {
+  "agent": {
+    "value": "agent",
+    "label": "Agent"
+  },
+  "chat": {
+    "value": "chat",
+    "label": "Chat"
+  },
+  "document": {
+    "value": "document",
+    "label": "Document"
+  },
+  "entity": {
+    "value": "entity",
+    "label": "Entity"
+  },
+  "productivity": {
+    "value": "productivity",
+    "label": "Productivity"
+  }
+};
+export {
+  AccountingNodeSubTypes,
+  ActionNodeSubTypes,
+  AgentNodeSubTypes,
+  DataNodeSubTypes,
+  DelayNodeSubTypes,
+  DynamicSchemaForm,
+  EdgeStatusCompleted,
+  EdgeStatusPending,
+  EdgeStatusSkipped,
+  EdgeTypeCompensation,
+  EdgeTypeConditional,
+  EdgeTypeDefault,
+  EdgeTypeError,
+  EdgeTypeLoopBack,
+  EdgeTypeMerge,
+  EdgeTypeNormal,
+  EdgeTypeParallel,
+  EdgeTypeTimeout,
+  ExpressionTypeDSL,
+  ExpressionTypeFilter,
+  ExpressionTypeJavaScript,
+  ExpressionTypeRules,
+  ExpressionTypeTemplate,
+  HumanActionNodeSubTypes,
+  InstanceStatusCompleted,
+  InstanceStatusFailed,
+  InstanceStatusNew,
+  InstanceStatusPaused,
+  InstanceStatusRunning,
+  InstanceStatusWaiting,
+  LogicNodeSubTypes,
+  LoopNodeSubTypes,
+  NodeStatusCompleted,
+  NodeStatusFailed,
+  NodeStatusPending,
+  NodeStatusRunning,
+  NodeStatusSkipped,
+  NodeStatusWaiting,
+  NodeSubTypeActionApiCall,
+  NodeSubTypeActionAssignSLAPolicy,
+  NodeSubTypeActionCSATSurvey,
+  NodeSubTypeActionChangeSLAStatus,
+  NodeSubTypeActionCreateEntityRecord,
+  NodeSubTypeActionDeleteEntityRecord,
+  NodeSubTypeActionDocumentExtraction,
+  NodeSubTypeActionEscalateSLA,
+  NodeSubTypeActionGenerateDocument,
+  NodeSubTypeActionMergeEntityRecords,
+  NodeSubTypeActionNatsRequest,
+  NodeSubTypeActionProcessPayment,
+  NodeSubTypeActionQueryEntityRecords,
+  NodeSubTypeActionSendEmail,
+  NodeSubTypeActionSendSMS,
+  NodeSubTypeActionSetVariables,
+  NodeSubTypeActionUpdateEntityRecord,
+  NodeSubTypeAgentApiIntegration,
+  NodeSubTypeAgentChat,
+  NodeSubTypeAgentClientApiCall,
+  NodeSubTypeAgentCustomResponse,
+  NodeSubTypeAgentIntentDetector,
+  NodeSubTypeAgentKnowledgeGraph,
+  NodeSubTypeAgentOpenTicket,
+  NodeSubTypeAgentStructuredOutput,
+  NodeSubTypeAgentTransferToHuman,
+  NodeSubTypeDataCalculate,
+  NodeSubTypeDataFilter,
+  NodeSubTypeDataMap,
+  NodeSubTypeDataValidate,
+  NodeSubTypeDelay,
+  NodeSubTypeHumanActionApproval,
+  NodeSubTypeHumanActionAssignment,
+  NodeSubTypeHumanActionDataEntry,
+  NodeSubTypeHumanActionReview,
+  NodeSubTypeLogicFor,
+  NodeSubTypeLogicIf,
+  NodeSubTypeLogicParallel,
+  NodeSubTypeLogicSwitch,
+  NodeSubTypeLoopData,
+  NodeSubTypeTimerBusinessHours,
+  NodeSubTypeTimerDelay,
+  NodeSubTypeTimerSchedule,
+  NodeSubTypeTriggerEntityRecordCreated,
+  NodeSubTypeTriggerEntityRecordDeleted,
+  NodeSubTypeTriggerEntityRecordUpdated,
+  NodeSubTypeTriggerEscalation,
+  NodeSubTypeTriggerSLABreach,
+  NodeSubTypeTriggerSLAWarning,
+  NodeSubTypeTriggerStart,
+  NodeSubTypeTriggerWebhookReceived,
+  NodeTypeAccounting,
+  NodeTypeAction,
+  NodeTypeAgent,
+  NodeTypeCustom,
+  NodeTypeData,
+  NodeTypeDelay,
+  NodeTypeHumanAction,
+  NodeTypeIntegration,
+  NodeTypeLogic,
+  NodeTypeLoop,
+  NodeTypeParallel,
+  NodeTypeSubflow,
+  NodeTypeTimer,
+  NodeTypeTrigger,
+  ParallelNodeSubTypes,
+  PersistenceTypeEphemeral,
+  PersistenceTypePermanent,
+  RuleLevelError,
+  RuleLevelInfo,
+  RuleLevelWarning,
+  SchemaBuilder,
+  TimeoutActionAlt,
+  TimeoutActionFail,
+  TimeoutActionRetry,
+  TimeoutActionSkip,
+  TimerNodeSubTypes,
+  TriggerNodeSubTypes,
+  WorkflowDefinitionContext,
+  WorkflowDefinitionCreate,
+  WorkflowDefinitionCreated,
+  WorkflowDefinitionDelete,
+  WorkflowDefinitionDeleted,
+  WorkflowDefinitionGet,
+  WorkflowDefinitionGetByTitle,
+  WorkflowDefinitionGetServer,
+  WorkflowDefinitionList,
+  WorkflowDefinitionProvider,
+  WorkflowDefinitionUpdate,
+  WorkflowDefinitionUpdated,
+  WorkflowEdgeTypes,
+  WorkflowExecutionCompleted,
+  WorkflowExecutionFailed,
+  WorkflowExecutionStarted,
+  WorkflowInstanceContext,
+  WorkflowInstanceCreate,
+  WorkflowInstanceExecuteNode,
+  WorkflowInstanceExecuteNodeLean,
+  WorkflowInstanceExecuteNodeLeanServer,
+  WorkflowInstanceExecuteNodeServer,
+  WorkflowInstanceGet,
+  WorkflowInstanceList,
+  WorkflowInstanceProvider,
+  WorkflowInstanceResumeNode,
+  WorkflowInstanceResumeNodeServer,
+  WorkflowInstanceUpdate,
+  WorkflowInstanceUpdateNodeMetadata,
+  WorkflowInstanceUpdated,
+  WorkflowNodeTypes,
+  WorkflowScheduleCreate,
+  WorkflowScheduleDelete,
+  WorkflowScheduleList,
+  WorkflowSchedulePause,
+  WorkflowScheduleResume,
+  WorkflowScheduleUpdate,
+  WorkflowTemplateGet,
+  WorkflowTemplateInstantiate,
+  WorkflowTemplateList,
+  WorkflowTriggerFired,
+  WorkflowTriggerPause,
+  WorkflowTriggerRegister,
+  WorkflowTriggerResume,
+  WorkflowTriggerStatus,
+  WorkflowTypeAgent,
+  WorkflowTypeChat,
+  WorkflowTypeDocument,
+  WorkflowTypeEntity,
+  WorkflowTypeProductivity,
+  WorkflowTypes,
+  nodeDefinitions,
+  nodeSchemas,
+  useWorkflowDefinition,
+  useWorkflowDefinitionContext,
+  useWorkflowInstance,
+  useWorkflowInstanceContext,
+  workflowDefinitionReducer,
+  workflowInstanceReducer
+};
+//# sourceMappingURL=index.mjs.map