ezux 1.1.13 → 1.1.18

package/dist/card-ZUNxcdIM.js

@@ -0,0 +1,60 @@
+import { _ as e, r as t } from "./EzProvider-AlmsYIDk.js";
+import "react";
+import { jsx as n } from "react/jsx-runtime";
+//#region src/shared/hooks/useI18n.ts
+var r = () => t();
+//#endregion
+//#region src/components/ui/textarea.tsx
+function i({ className: t, ref: r, ...i }) {
+	return /* @__PURE__ */ n("textarea", {
+		className: e("flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50", t),
+		ref: r,
+		...i
+	});
+}
+//#endregion
+//#region src/components/ui/card.tsx
+function a({ className: t, ref: r, ...i }) {
+	return /* @__PURE__ */ n("div", {
+		ref: r,
+		className: e("rounded-xl border bg-card text-card-foreground shadow", t),
+		...i
+	});
+}
+function o({ className: t, ref: r, ...i }) {
+	return /* @__PURE__ */ n("div", {
+		ref: r,
+		className: e("flex flex-col space-y-1.5 p-6", t),
+		...i
+	});
+}
+function s({ className: t, ref: r, ...i }) {
+	return /* @__PURE__ */ n("div", {
+		ref: r,
+		className: e("font-semibold leading-none tracking-tight", t),
+		...i
+	});
+}
+function c({ className: t, ref: r, ...i }) {
+	return /* @__PURE__ */ n("div", {
+		ref: r,
+		className: e("text-sm text-muted-foreground", t),
+		...i
+	});
+}
+function l({ className: t, ref: r, ...i }) {
+	return /* @__PURE__ */ n("div", {
+		ref: r,
+		className: e("p-6 pt-0", t),
+		...i
+	});
+}
+function u({ className: t, ref: r, ...i }) {
+	return /* @__PURE__ */ n("div", {
+		ref: r,
+		className: e("flex items-center p-6 pt-0", t),
+		...i
+	});
+}
+//#endregion
+export { o as a, r as c, u as i, l as n, s as o, c as r, i as s, a as t };

package/dist/checkbox-BrCh_Iid.cjs

@@ -0,0 +1 @@
+const e=require("./EzProvider-L2qQMq-v.cjs");let t=require("react");t=e.y(t,1);let n=require("react/jsx-runtime");function r({className:r,checked:i,onCheckedChange:a,ref:o,...s}){let c=t.useRef(null);return t.useImperativeHandle(o,()=>c.current),t.useEffect(()=>{c.current&&(c.current.indeterminate=i===`indeterminate`)},[i]),(0,n.jsx)(`input`,{type:`checkbox`,className:e._(`peer h-4 w-4 shrink-0 rounded-sm border border-zinc-200 border-zinc-900 ring-offset-white focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-zinc-950 focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-zinc-900 data-[state=checked]:text-zinc-50 dark:border-zinc-800 dark:border-zinc-50 dark:ring-offset-zinc-950 dark:focus-visible:ring-zinc-300 dark:data-[state=checked]:bg-zinc-50 dark:data-[state=checked]:text-zinc-900`,`accent-zinc-900 dark:accent-zinc-50`,r),ref:c,checked:i===`indeterminate`?!1:i,onChange:e=>{a?.(e.target.checked)},...s})}Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return r}});

package/dist/checkbox-DRkQuB4W.js

@@ -0,0 +1,21 @@
+import { _ as e } from "./EzProvider-AlmsYIDk.js";
+import * as t from "react";
+import { jsx as n } from "react/jsx-runtime";
+//#region src/components/ui/checkbox.tsx
+function r({ className: r, checked: i, onCheckedChange: a, ref: o, ...s }) {
+	let c = t.useRef(null);
+	return t.useImperativeHandle(o, () => c.current), t.useEffect(() => {
+		c.current && (c.current.indeterminate = i === "indeterminate");
+	}, [i]), /* @__PURE__ */ n("input", {
+		type: "checkbox",
+		className: e("peer h-4 w-4 shrink-0 rounded-sm border border-zinc-200 border-zinc-900 ring-offset-white focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-zinc-950 focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-zinc-900 data-[state=checked]:text-zinc-50 dark:border-zinc-800 dark:border-zinc-50 dark:ring-offset-zinc-950 dark:focus-visible:ring-zinc-300 dark:data-[state=checked]:bg-zinc-50 dark:data-[state=checked]:text-zinc-900", "accent-zinc-900 dark:accent-zinc-50", r),
+		ref: c,
+		checked: i === "indeterminate" ? !1 : i,
+		onChange: (e) => {
+			a?.(e.target.checked);
+		},
+		...s
+	});
+}
+//#endregion
+export { r as t };

package/dist/components/EzFlow/EzConnectionLine.d.ts

@@ -0,0 +1,5 @@
+import { ConnectionLineComponentProps } from '@xyflow/react';
+export declare const EzConnectionLine: {
+    ({ fromX, fromY, toX, toY, fromPosition, toPosition, fromHandle, }: ConnectionLineComponentProps): import("react").JSX.Element;
+    displayName: string;
+};

package/dist/components/EzFlow/EzFlow.examples.d.ts

@@ -0,0 +1,5 @@
+import { EzFlowSerializedState } from './EzFlow.types';
+export declare const approvalWorkflowExample: EzFlowSerializedState;
+export declare const apiRequestWorkflowExample: EzFlowSerializedState;
+export declare const scheduledWorkflowExample: EzFlowSerializedState;
+export declare const humanReviewWorkflowExample: EzFlowSerializedState;

package/dist/components/EzFlow/EzFlow.types.d.ts

@@ -0,0 +1,260 @@
+import { Node, Edge, EdgeProps, NodeProps, NodeTypes, EdgeTypes, OnNodesChange, OnEdgesChange, OnConnect } from '@xyflow/react';
+export type EzFlowNodeCategory = 'flow_control' | 'logic' | 'execution' | 'human' | 'structural';
+export interface EzFlowBaseNodeData extends Record<string, unknown> {
+    label: string;
+    description?: string;
+}
+export interface StartNodeData extends EzFlowBaseNodeData {
+    triggerType?: 'manual' | 'scheduled' | 'webhook';
+}
+export interface EndNodeData extends EzFlowBaseNodeData {
+    outcome?: 'success' | 'failure' | 'cancelled';
+}
+export interface DecisionNodeData extends EzFlowBaseNodeData {
+    condition?: string;
+    branches?: Array<{
+        id: string;
+        label: string;
+        condition?: string;
+    }>;
+}
+export interface LoopNodeData extends EzFlowBaseNodeData {
+    iteratorSource?: string;
+    maxIterations?: number;
+}
+export interface ActionNodeData extends EzFlowBaseNodeData {
+    actionType?: string;
+    config?: Record<string, unknown>;
+}
+export interface RequestNodeData extends EzFlowBaseNodeData {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    url?: string;
+    headers?: Record<string, string>;
+}
+export interface DelayNodeData extends EzFlowBaseNodeData {
+    duration?: number;
+    unit?: 'seconds' | 'minutes' | 'hours' | 'days';
+}
+export interface ApprovalNodeData extends EzFlowBaseNodeData {
+    approverRole?: string;
+    escalationRole?: string;
+    slaHours?: number;
+}
+export interface GroupNodeData extends EzFlowBaseNodeData {
+    collapsed?: boolean;
+}
+export type EzFlowNodeData = StartNodeData | EndNodeData | DecisionNodeData | LoopNodeData | ActionNodeData | RequestNodeData | DelayNodeData | ApprovalNodeData | GroupNodeData;
+export type EzFlowNodeType = 'startNode' | 'endNode' | 'decisionNode' | 'loopNode' | 'actionNode' | 'requestNode' | 'delayNode' | 'approvalNode' | 'groupNode';
+export interface EzFlowNodeLibraryItem {
+    type: EzFlowNodeType;
+    labelKey: string;
+    descriptionKey?: string;
+    category: EzFlowNodeCategory;
+    icon: React.ReactNode;
+    defaultData?: Partial<EzFlowNodeData>;
+}
+export interface EzFlowNodeLibraryCategory {
+    categoryKey: string;
+    category: EzFlowNodeCategory;
+    items: EzFlowNodeLibraryItem[];
+}
+export interface EzFlowToolboxProps {
+    categories: EzFlowNodeLibraryCategory[];
+    title?: string;
+    className?: string;
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    onNodeActivate?: (item: EzFlowNodeLibraryItem) => void;
+}
+export interface EzFlowCanvasProps extends React.HTMLAttributes<HTMLDivElement> {
+    nodes: Node[];
+    edges: Edge[];
+    onNodesChange: OnNodesChange;
+    onEdgesChange: OnEdgesChange;
+    onConnect: OnConnect;
+    nodeTypes?: NodeTypes;
+    edgeTypes?: EdgeTypes;
+    onDrop?: (event: React.DragEvent) => void;
+    onDragOver?: (event: React.DragEvent) => void;
+    onNodeClick?: (event: React.MouseEvent, node: Node) => void;
+    onNodeDoubleClick?: (event: React.MouseEvent, node: Node) => void;
+    onEdgeClick?: (event: React.MouseEvent, edge: Edge) => void;
+    onEdgeDelete?: (edgeId: string) => void;
+    onPaneClick?: (event: React.MouseEvent) => void;
+    isValidConnection?: (connection: {
+        source: string | null;
+        target: string | null;
+    }) => boolean;
+    snapToGrid?: boolean;
+    snapGrid?: [number, number];
+    showGrid?: boolean;
+    fitView?: boolean;
+    readOnly?: boolean;
+}
+export type EzFlowStatus = 'draft' | 'live' | 'archived';
+export interface EzFlowHeaderProps {
+    title: string;
+    description?: string;
+    status?: EzFlowStatus;
+    isDirty?: boolean;
+    onTitleChange?: (title: string) => void;
+    onDescriptionChange?: (description: string) => void;
+    onSave?: () => void;
+    onPublish?: () => void;
+    onCancel?: () => void;
+    showGrid?: boolean;
+    onShowGridChange?: (show: boolean) => void;
+    snapToGrid?: boolean;
+    onSnapToGridChange?: (snap: boolean) => void;
+    className?: string;
+}
+export type EzFlowEdgeProps = EdgeProps & {
+    onDelete?: (id: string) => void;
+};
+export interface EzFlowSerializedState {
+    nodes: Node[];
+    edges: Edge[];
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    metadata?: {
+        title?: string;
+        description?: string;
+        status?: EzFlowStatus;
+        version?: number;
+        updatedAt?: string;
+        publishedAt?: string;
+    };
+}
+export type EzWorkflowValidationSeverity = 'error' | 'warning';
+export type EzWorkflowValidationCode = 'missing_start' | 'missing_end' | 'missing_end_path' | 'orphan_node' | 'invalid_cycle' | 'missing_required_config' | 'missing_decision_branch';
+export interface EzWorkflowValidationIssue {
+    code: EzWorkflowValidationCode;
+    severity: EzWorkflowValidationSeverity;
+    message: string;
+    nodeId?: string;
+    edgeId?: string;
+    field?: string;
+}
+export interface EzWorkflowValidationResult {
+    valid: boolean;
+    issues: EzWorkflowValidationIssue[];
+}
+export interface EzWorkflowNodeInput<TData extends EzFlowBaseNodeData = EzFlowNodeData> {
+    id?: string;
+    type: EzFlowNodeType | string;
+    data?: Partial<TData>;
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+export interface EzWorkflowNodeEvent<TData extends EzFlowBaseNodeData = EzFlowNodeData> {
+    node: Node<TData>;
+    workflow: EzFlowSerializedState;
+}
+export interface EzWorkflowConnectionEvent {
+    edge: Edge;
+    sourceId: string;
+    targetId: string;
+    workflow: EzFlowSerializedState;
+}
+export interface EzWorkflowNodeEditorProps<TData extends EzFlowBaseNodeData = EzFlowNodeData> {
+    node: Node<TData>;
+    data: TData;
+    onChange: (updates: Partial<TData>) => void;
+    readOnly?: boolean;
+    issues?: EzWorkflowValidationIssue[];
+}
+export interface EzWorkflowNodeRegistryItem<TData extends EzFlowBaseNodeData = EzFlowNodeData> {
+    type: EzFlowNodeType | string;
+    label: string;
+    description?: string;
+    category: EzFlowNodeCategory;
+    icon?: React.ReactNode;
+    component?: React.ComponentType<NodeProps<Node<TData>>>;
+    defaultData: TData;
+    requiredDataKeys?: readonly (keyof TData & string)[];
+    validate?: (node: Node<TData>, workflow: EzFlowSerializedState) => EzWorkflowValidationIssue[];
+    editor?: React.ComponentType<EzWorkflowNodeEditorProps<TData>>;
+}
+export type EzWorkflowNodeRegistry = Record<string, EzWorkflowNodeRegistryItem>;
+export interface IWorkflowService {
+    loadWorkflow(id: string): Promise<EzFlowSerializedState>;
+    saveWorkflow(id: string, workflow: EzFlowSerializedState): Promise<void>;
+    publishWorkflow(id: string, workflow: EzFlowSerializedState): Promise<void>;
+    validateWorkflow(workflow: EzFlowSerializedState): Promise<EzWorkflowValidationResult>;
+}
+export interface EzWorkflowRestServiceOptions {
+    baseUrl: string;
+    fetcher?: typeof fetch;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+}
+export interface EzWorkflowPerformanceSample {
+    nodeCount: number;
+    edgeCount: number;
+    validateMs: number;
+    valid: boolean;
+    issueCount: number;
+}
+export interface EzWorkflowRef {
+    getWorkflow(): EzFlowSerializedState;
+    setWorkflow(workflow: EzFlowSerializedState): void;
+    validate(): EzWorkflowValidationResult;
+    addNode(node: EzWorkflowNodeInput): void;
+    updateNode(id: string, updates: Partial<EzFlowNodeData>): void;
+    deleteNode(id: string): void;
+    connect(sourceId: string, targetId: string): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    fitView(): void;
+    exportJson(): string;
+    importJson(json: string): void;
+}
+export interface EzWorkflowProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'onError'> {
+    workflow?: EzFlowSerializedState;
+    defaultWorkflow?: EzFlowSerializedState;
+    workflowId?: string;
+    service?: IWorkflowService;
+    nodeRegistry?: EzWorkflowNodeRegistry;
+    onWorkflowChange?: (workflow: EzFlowSerializedState) => void;
+    onNodeAdd?: (args: EzWorkflowNodeEvent) => void;
+    onNodeUpdate?: (args: EzWorkflowNodeEvent) => void;
+    onNodeDelete?: (args: EzWorkflowNodeEvent) => void;
+    onConnectionCreate?: (args: EzWorkflowConnectionEvent) => void;
+    onValidationChange?: (result: EzWorkflowValidationResult) => void;
+    onSave?: (workflow: EzFlowSerializedState) => void | Promise<void>;
+    onPublish?: (workflow: EzFlowSerializedState) => void | Promise<void>;
+    onError?: (error: Error, action: 'load' | 'save' | 'publish' | 'import' | 'validate') => void;
+    title?: string;
+    description?: string;
+    status?: EzFlowStatus;
+    toolboxTitle?: string;
+    showHeader?: boolean;
+    showToolbox?: boolean;
+    showInspector?: boolean;
+    showValidationPanel?: boolean;
+    showActionBar?: boolean;
+    autoValidate?: boolean;
+    readOnly?: boolean;
+    showGrid?: boolean;
+    snapToGrid?: boolean;
+    fitView?: boolean;
+    exportFileName?: string;
+    classNames?: {
+        root?: string;
+        header?: string;
+        body?: string;
+        toolbox?: string;
+        canvas?: string;
+        inspector?: string;
+        validationPanel?: string;
+        actionBar?: string;
+    };
+}
+export type EzFlowProps = EzWorkflowProps;
+export type EzFlowRef = EzWorkflowRef;

package/dist/components/EzFlow/EzFlowBackground.d.ts

@@ -0,0 +1,5 @@
+import { BackgroundProps } from '@xyflow/react';
+export declare const EzFlowBackground: {
+    (props: BackgroundProps): import("react").JSX.Element;
+    displayName: string;
+};

package/dist/components/EzFlow/EzFlowCanvas.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { EzFlowCanvasProps } from './EzFlow.types';
+export declare const EzFlowCanvas: React.ForwardRefExoticComponent<EzFlowCanvasProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/EzFlow/EzFlowControls.d.ts

@@ -0,0 +1,5 @@
+import { ControlProps } from '@xyflow/react';
+export declare const EzFlowControls: {
+    (props: ControlProps): import("react").JSX.Element;
+    displayName: string;
+};

package/dist/components/EzFlow/EzFlowEdge.d.ts

@@ -0,0 +1,5 @@
+import { EzFlowEdgeProps } from './EzFlow.types';
+export declare const EzFlowEdge: {
+    ({ sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, label, data, id, onDelete, }: EzFlowEdgeProps): import("react").JSX.Element;
+    displayName: string;
+};

package/dist/components/EzFlow/EzFlowHeader.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { EzFlowHeaderProps } from './EzFlow.types';
+export declare const EzFlowHeader: {
+    ({ title, description, status, isDirty, onTitleChange, onDescriptionChange, onSave, onPublish, onCancel, showGrid, onShowGridChange, snapToGrid, onSnapToGridChange, className, }: EzFlowHeaderProps): React.JSX.Element;
+    displayName: string;
+};

package/dist/components/EzFlow/EzFlowToolbox.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { EzFlowToolboxProps } from './EzFlow.types';
+export declare const EzFlowToolbox: {
+    ({ categories, title, className, collapsed, onCollapsedChange, onNodeActivate, }: EzFlowToolboxProps): React.JSX.Element;
+    displayName: string;
+};

package/dist/components/EzFlow/EzWorkflow.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { EzWorkflowProps, EzWorkflowRef } from './EzFlow.types';
+export { createEzWorkflowNodeLibrary, ezWorkflowDefaultNodeRegistry, validateEzWorkflow, validateWorkflow, } from './EzWorkflowValidation';
+export declare const EzWorkflow: React.ForwardRefExoticComponent<EzWorkflowProps & React.RefAttributes<EzWorkflowRef>>;
+export declare const EzFlow: React.ForwardRefExoticComponent<EzWorkflowProps & React.RefAttributes<EzWorkflowRef>>;

package/dist/components/EzFlow/EzWorkflowPerformance.d.ts

@@ -0,0 +1,3 @@
+import { EzFlowSerializedState, EzWorkflowPerformanceSample } from './EzFlow.types';
+export declare const createLargeEzWorkflow: (nodeCount: number) => EzFlowSerializedState;
+export declare const measureEzWorkflowValidation: (nodeCount: number) => EzWorkflowPerformanceSample;

package/dist/components/EzFlow/EzWorkflowServiceAdapters.d.ts

@@ -0,0 +1,24 @@
+import { EzFlowSerializedState, EzWorkflowRestServiceOptions, EzWorkflowValidationResult, IWorkflowService } from './EzFlow.types';
+export declare class EzWorkflowRestService implements IWorkflowService {
+    private readonly baseUrl;
+    private readonly fetcher;
+    private readonly headers?;
+    constructor(options: EzWorkflowRestServiceOptions);
+    loadWorkflow(id: string): Promise<EzFlowSerializedState>;
+    saveWorkflow(id: string, workflow: EzFlowSerializedState): Promise<void>;
+    publishWorkflow(id: string, workflow: EzFlowSerializedState): Promise<void>;
+    validateWorkflow(workflow: EzFlowSerializedState): Promise<EzWorkflowValidationResult>;
+}
+export declare class EzWorkflowOptimisticService implements IWorkflowService {
+    private readonly service;
+    private lastStableWorkflow?;
+    constructor(service: IWorkflowService);
+    getRollbackWorkflow(): EzFlowSerializedState | undefined;
+    loadWorkflow(id: string): Promise<EzFlowSerializedState>;
+    saveWorkflow(id: string, workflow: EzFlowSerializedState): Promise<void>;
+    publishWorkflow(id: string, workflow: EzFlowSerializedState): Promise<void>;
+    validateWorkflow(workflow: EzFlowSerializedState): Promise<EzWorkflowValidationResult>;
+}
+export declare const createLocalEzWorkflowService: (initial?: Record<string, EzFlowSerializedState>) => IWorkflowService & {
+    workflows: Map<string, EzFlowSerializedState>;
+};

package/dist/components/EzFlow/EzWorkflowValidation.d.ts

@@ -0,0 +1,95 @@
+import { EzFlowNodeData, EzFlowNodeLibraryCategory, EzFlowSerializedState, EzWorkflowNodeRegistry, EzWorkflowValidationResult } from './EzFlow.types';
+export declare const emptyWorkflow: EzFlowSerializedState;
+export declare const ezWorkflowDefaultNodeRegistry: {
+    startNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "flow_control";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+    };
+    endNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "flow_control";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+    };
+    decisionNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "logic";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+        requiredDataKeys: string[];
+    };
+    loopNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "flow_control";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+        requiredDataKeys: string[];
+    };
+    actionNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "execution";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+        requiredDataKeys: string[];
+    };
+    requestNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "execution";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+        requiredDataKeys: string[];
+    };
+    delayNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "logic";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+        requiredDataKeys: string[];
+    };
+    approvalNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "human";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+        requiredDataKeys: string[];
+    };
+    groupNode: {
+        type: string;
+        label: string;
+        description: string;
+        category: "structural";
+        icon: import("react").JSX.Element;
+        component: import('react').MemoExoticComponent<({ data, selected }: import('@xyflow/react').NodeProps) => import("react").JSX.Element>;
+        defaultData: EzFlowNodeData;
+    };
+};
+export declare const cloneWorkflow: (workflow: EzFlowSerializedState) => EzFlowSerializedState;
+export declare const createEzWorkflowNodeLibrary: (registry?: EzWorkflowNodeRegistry) => EzFlowNodeLibraryCategory[];
+export declare const validateEzWorkflow: (workflow: EzFlowSerializedState, registry?: EzWorkflowNodeRegistry) => EzWorkflowValidationResult;
+export declare const validateWorkflow: (workflow: EzFlowSerializedState, registry?: EzWorkflowNodeRegistry) => EzWorkflowValidationResult;

package/dist/components/EzFlow/index.d.ts

@@ -0,0 +1,13 @@
+export { EzFlowCanvas } from './EzFlowCanvas';
+export { EzFlowEdge } from './EzFlowEdge';
+export { EzFlowControls } from './EzFlowControls';
+export { EzFlowBackground } from './EzFlowBackground';
+export { EzConnectionLine } from './EzConnectionLine';
+export { EzFlowToolbox } from './EzFlowToolbox';
+export { EzFlowHeader } from './EzFlowHeader';
+export { EzWorkflow, EzFlow, createEzWorkflowNodeLibrary, validateEzWorkflow, validateWorkflow, ezWorkflowDefaultNodeRegistry, } from './EzWorkflow';
+export { EzWorkflowRestService, EzWorkflowOptimisticService, createLocalEzWorkflowService, } from './EzWorkflowServiceAdapters';
+export { createLargeEzWorkflow, measureEzWorkflowValidation } from './EzWorkflowPerformance';
+export { approvalWorkflowExample, apiRequestWorkflowExample, scheduledWorkflowExample, humanReviewWorkflowExample, } from './EzFlow.examples';
+export { StartNode, EndNode, DecisionNode, LoopNode, ActionNode, RequestNode, DelayNode, ApprovalNode, GroupNode, } from './nodes';
+export type { EzFlowNodeCategory, EzFlowBaseNodeData, StartNodeData, EndNodeData, DecisionNodeData, LoopNodeData, ActionNodeData, RequestNodeData, DelayNodeData, ApprovalNodeData, GroupNodeData, EzFlowNodeData, EzFlowNodeType, EzFlowNodeLibraryItem, EzFlowNodeLibraryCategory, EzFlowToolboxProps, EzFlowCanvasProps, EzFlowStatus, EzFlowHeaderProps, EzFlowEdgeProps, EzFlowSerializedState, EzWorkflowValidationSeverity, EzWorkflowValidationCode, EzWorkflowValidationIssue, EzWorkflowValidationResult, EzWorkflowNodeInput, EzWorkflowNodeEvent, EzWorkflowConnectionEvent, EzWorkflowNodeEditorProps, EzWorkflowNodeRegistryItem, EzWorkflowNodeRegistry, IWorkflowService, EzWorkflowRestServiceOptions, EzWorkflowPerformanceSample, EzWorkflowRef, EzWorkflowProps, EzFlowProps, EzFlowRef, } from './EzFlow.types';

package/dist/components/EzFlow/nodes/ActionNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const ActionNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/ApprovalNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const ApprovalNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/DecisionNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const DecisionNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/DelayNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const DelayNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/EndNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const EndNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/GroupNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const GroupNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/LoopNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const LoopNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/RequestNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const RequestNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/StartNode.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const StartNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => React.JSX.Element>;

package/dist/components/EzFlow/nodes/index.d.ts

@@ -0,0 +1,9 @@
+export { StartNode } from './StartNode';
+export { EndNode } from './EndNode';
+export { DecisionNode } from './DecisionNode';
+export { LoopNode } from './LoopNode';
+export { ActionNode } from './ActionNode';
+export { RequestNode } from './RequestNode';
+export { DelayNode } from './DelayNode';
+export { ApprovalNode } from './ApprovalNode';
+export { GroupNode } from './GroupNode';