@republicroad/seal-editor 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2515 @@
+import { default as default_2 } from 'react';
+import { Dispatch } from 'react';
+import { DragDropManager } from 'dnd-core';
+import { EdgeChange } from '@xyflow/react';
+import { editor } from 'monaco-editor';
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { Extension } from '@codemirror/state';
+import { ForwardRefExoticComponent } from 'react';
+import { HandleProps } from '@xyflow/react';
+import { linter } from '@codemirror/lint';
+import { Monaco } from '@monaco-editor/react';
+import { MutableRefObject } from 'react';
+import { Node as Node_2 } from '@xyflow/react';
+import { NodeChange } from '@xyflow/react';
+import { NodeProps } from '@xyflow/react';
+import { ProOptions } from '@xyflow/react';
+import * as React_2 from 'react';
+import { ReactFlowInstance } from '@xyflow/react';
+import { RefAttributes } from 'react';
+import { RefObject } from 'react';
+import { SetStateAction } from 'react';
+import { StoreApi } from 'zustand';
+import { UseBoundStore } from 'zustand';
+import { useEdgesState } from '@xyflow/react';
+import { useNodesState } from '@xyflow/react';
+import { Variable } from '@gorules/zen-engine-wasm';
+import { VariableType } from '@gorules/zen-engine-wasm';
+import { WritableDraft } from 'immer';
+import { XYPosition } from '@xyflow/react';
+import { z } from 'zod';
+
+export declare const addStrikethrough: (text?: string) => string;
+
+export declare const anyNodeSchema: z.ZodObject<{
+    type: z.ZodString;
+    content: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare type Arrayable<T> = T | T[];
+
+export declare const AUTO_SYNC_DEBOUNCE_MS = 700;
+
+declare type AutosizeTextAreaProps = {
+    maxRows: number;
+    noStyle?: boolean;
+    value?: string;
+    onChange?: default_2.ChangeEventHandler<HTMLTextAreaElement>;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    testId?: string;
+} & Omit<default_2.DetailedHTMLProps<default_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, 'onChange' | 'placeholder'>;
+
+declare interface BaseItem {
+    id?: string;
+    _id?: string;
+    [key: string]: any;
+}
+
+declare type BaseNode<Component extends string, InputName extends string, Inputs extends InputSchema<InputName>[], NodeData extends object = CreateDynamicType<Inputs>> = {
+    kind: Component;
+    icon?: default_2.ReactNode;
+    color?: string;
+    displayName: string;
+    shortDescription?: string;
+    group?: string;
+    handleLeft?: boolean;
+    handleRight?: boolean;
+    inputs?: [...Inputs];
+    generateNode?: CustomNodeSpecification<NodeData, Component>['generateNode'];
+    renderNode?: CustomNodeSpecification<NodeData, Component>['renderNode'];
+    onNodeAdd?: CustomNodeSpecification<NodeData, Component>['onNodeAdd'];
+};
+
+declare type BoolInput = {
+    control: 'bool';
+    label?: string;
+};
+
+export declare const buildDiffString: (currentValue: string, previousValue: string) => string;
+
+export declare const buildRequestExampleTemplateFromDefinitions: (definitions: Array<Pick<RequestDefinition, "name" | "path" | "type" | "defaultValue">>) => Record<string, unknown>;
+
+export declare const buildRequestSchemaFromDefinitions: (schemaValue: unknown, definitions: Array<Pick<RequestDefinition, "name" | "path" | "type" | "description" | "format" | "order" | "parentPath">>) => string;
+
+export declare const calculateDiffGraph: (currentGraph: DecisionGraphType, previousGraph: DecisionGraphType, options?: ProcessNodesOptions) => DecisionGraphType;
+
+export declare const clusterToolbarItems: (items: ToolbarItem[]) => ToolbarItem[];
+
+export declare const CodeEditor: default_2.ForwardRefExoticComponent<{
+    maxRows?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    onStateChange?: (state: EditorState) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    type?: "unary" | "standard" | "template";
+    lint?: boolean;
+    strict?: boolean;
+    fullHeight?: boolean;
+    noStyle?: boolean;
+    extension?: (params: {
+        type?: "standard" | "unary" | "template";
+    }) => Extension;
+    livePreview?: {
+        input: unknown;
+        fromSimulation: boolean;
+        result?: unknown;
+    };
+    variableType?: any;
+    expectedVariableType?: any;
+    lazy?: boolean;
+    initialSelection?: {
+        anchor: number;
+        head?: number;
+    };
+} & Omit<default_2.HTMLAttributes<HTMLDivElement>, "disabled" | "onChange"> & {
+    lazy?: boolean;
+} & default_2.RefAttributes<CodeEditorBaseRef>>;
+
+declare type CodeEditorBaseProps = {
+    maxRows?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    onStateChange?: (state: EditorState) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    type?: 'unary' | 'standard' | 'template';
+    lint?: boolean;
+    strict?: boolean;
+    fullHeight?: boolean;
+    noStyle?: boolean;
+    extension?: (params: ExtensionParams) => Extension;
+    livePreview?: {
+        input: unknown;
+        fromSimulation: boolean;
+        result?: unknown;
+    };
+    variableType?: any;
+    expectedVariableType?: any;
+    lazy?: boolean;
+    initialSelection?: {
+        anchor: number;
+        head?: number;
+    };
+} & Omit<default_2.HTMLAttributes<HTMLDivElement>, 'disabled' | 'onChange'>;
+
+declare type CodeEditorBaseRef = HTMLDivElement & {
+    codeMirror: EditorView | null;
+};
+
+export declare type CodeEditorProps = CodeEditorBaseProps & {
+    lazy?: boolean;
+};
+
+export declare type CodeEditorRef = CodeEditorBaseRef;
+
+export declare const codemirror: {
+    linter: typeof linter;
+};
+
+export declare const COLUMN_FIELD_TYPE_OPTIONS: {
+    value: ColumnFieldType['type'];
+    label: string;
+}[];
+
+export declare type ColumnEnum = z.infer<typeof columnEnumSchema>;
+
+export declare const columnEnumSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"inline">;
+    values: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    loose: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ref">;
+    ref: z.ZodString;
+    loose: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "type">;
+
+export declare type ColumnFieldType = z.infer<typeof columnFieldTypeSchema>;
+
+export declare const columnFieldTypeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"any">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"string">;
+    enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"inline">;
+        values: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        loose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ref">;
+        ref: z.ZodString;
+        loose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"date">;
+}, z.core.$strip>], "type">;
+
+declare type ColumnType = 'inputs' | 'outputs';
+
+export declare const compareAndUnifyLists: <T extends BaseItem>(newList: T[], oldList: T[], options?: DiffOptions<T>) => T[];
+
+export declare const compareStringFields: (field1?: string | null, field2?: string | null) => boolean;
+
+export declare const computeGraphDiff: (a: DecisionGraphType, b: DecisionGraphType) => GraphDiff;
+
+declare type ControlToType<T> = T extends keyof InputTypeMap ? InputTypeMap[T] : never;
+
+declare type CreateDynamicType<T extends ReadonlyArray<unknown>, Result = {}> = T extends readonly [infer First, ...infer Rest] ? First extends {
+    control: infer Control extends string;
+    name: infer Name extends string;
+} ? CreateDynamicType<Rest, Result & SplitPath<Name, ControlToType<Control>>> : Result : Result;
+
+export declare const createJdmNode: <Component extends string, InputName extends string, Inputs extends InputSchema<InputName>[]>(n: BaseNode<Component, InputName, Inputs>) => CustomNodeSpecification<any, Component>;
+
+export declare const createT: (locale: string, overrides?: I18nMessages) => (key: string, params?: InterpolationParams) => string;
+
+declare type CustomDecisionNode<T> = {
+    id: string;
+    name: string;
+    description?: string;
+    type?: string;
+    content?: T;
+    position: XYPosition;
+};
+
+export declare const CustomFunctionTable: default_2.FC<TabCustomFunctionProps>;
+
+export declare const CustomKind = "customNode";
+
+export declare const customNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"customNode">;
+    content: z.ZodObject<{
+        kind: z.ZodString;
+        config: z.ZodAny;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+export declare type CustomNodeSpecification<Data extends object, Component extends string> = {
+    kind: Component;
+    color?: string;
+    icon?: default_2.ReactNode;
+    displayName: string;
+    group?: string;
+    documentationUrl?: string;
+    shortDescription?: string;
+    renderTab?: (props: {
+        id: string;
+        user?: string;
+        customFunctions?: any;
+    }) => default_2.ReactNode;
+    calculateDiff?: (current: any, previous: any) => [any, any];
+    generateNode: (params: GenerateNodeParams_2) => Omit<DecisionNode, 'position' | 'id' | 'type' | 'content'> & {
+        config?: Data;
+    };
+    renderNode: default_2.FC<MinimalNodeProps & {
+        specification: MinimalNodeSpecification;
+    }>;
+    inferTypes?: {
+        needsUpdate: (state: InferTypeData<Data>, prevState: InferTypeData<Data>) => boolean;
+        determineOutputType: (state: InferTypeData<Data>) => VariableType;
+    };
+    onNodeAdd?: (node: CustomDecisionNode<{
+        kind: Component;
+        config: Data;
+    }>) => Promise<CustomDecisionNode<{
+        kind: Component;
+        config: Data;
+    }>>;
+};
+
+export declare const darkTokens: Record<string, string | number>;
+
+export declare const DECISION_GRAPH_CONTENT_TYPE = "application/vnd.gorules.decision";
+
+export declare type DecisionEdge = {
+    id: string;
+    name?: string;
+    sourceId: string;
+    targetId: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+    type?: string;
+    _diff?: {
+        status: DiffStatus;
+    };
+};
+
+export declare const DecisionGraph: ForwardRefExoticComponent<DecisionGraphWrapperProps & DecisionGraphEmptyType & RefAttributes<GraphRef>>;
+
+declare type DecisionGraphContextProps = {};
+
+declare type DecisionGraphEmptyType = {
+    id?: string;
+    defaultValue?: DecisionGraphType;
+    value?: DecisionGraphType;
+    disabled?: boolean;
+    diffBaseline?: DecisionGraphType;
+    components?: DecisionGraphStoreType['state']['components'];
+    customNodes?: DecisionGraphStoreType['state']['customNodes'];
+    hideLeftToolbar?: DecisionGraphStoreType['state']['hideLeftToolbar'];
+    name?: DecisionGraphStoreType['state']['name'];
+    viewConfigCta?: DecisionGraphStoreType['state']['viewConfigCta'];
+    viewConfig?: DecisionGraphStoreType['state']['viewConfig'];
+    onViewConfigCta?: DecisionGraphStoreType['listeners']['onViewConfigCta'];
+    defaultActivePanel?: string;
+    panels?: DecisionGraphStoreType['state']['panels'];
+    onPanelsChange?: DecisionGraphStoreType['listeners']['onPanelsChange'];
+    simulate?: DecisionGraphStoreType['state']['simulate'];
+    dictionaries?: DictionaryMap;
+    mode?: JdmUiMode;
+    onChange?: DecisionGraphStoreType['listeners']['onChange'];
+    onReactFlowInit?: DecisionGraphStoreType['listeners']['onReactFlowInit'];
+    onCodeExtension?: DecisionGraphStoreType['listeners']['onCodeExtension'];
+    onFunctionReady?: DecisionGraphStoreType['listeners']['onFunctionReady'];
+};
+
+export declare type DecisionGraphProps = {} & DecisionGraphWrapperProps & DecisionGraphContextProps & DecisionGraphEmptyType;
+
+export declare type DecisionGraphRef = GraphRef;
+
+export declare type DecisionGraphSnapshot = {
+    graph?: Record<string, unknown>;
+    tabs?: Record<string, TabSnapshot>;
+};
+
+declare type DecisionGraphStoreType = {
+    state: {
+        id?: string;
+        hideLeftToolbar?: boolean;
+        components: NodeSpecification[];
+        disabled?: boolean;
+        decisionGraph: DecisionGraphType;
+        hoveredEdgeId: string | null;
+        openTabs: string[];
+        activeTab: string;
+        viewConfigCta?: string;
+        viewConfig?: ViewConfig;
+        name: string;
+        canUndo: boolean;
+        canRedo: boolean;
+        customNodes: CustomNodeSpecification<object, any>[];
+        panels?: PanelType[];
+        activePanel?: string;
+        onPanelsChange?: (val?: string) => void;
+        simulate?: Simulation;
+        user: string;
+        simulatorRequest?: string;
+        simulatorExampleBinding?: SimulatorExampleBinding;
+        compactMode?: boolean;
+        dictionaries?: DictionaryMap;
+        mode?: JdmUiMode;
+        nodeTypes: Record<string, Partial<Record<NodeTypeKind, VariableType>>>;
+        globalType: Record<string, VariableType>;
+    };
+    references: {
+        nodesState: MutableRefObject<ReturnType<typeof useNodesState>>;
+        edgesState: MutableRefObject<ReturnType<typeof useEdgesState>>;
+        reactFlowInstance: MutableRefObject<ReactFlowInstance | null>;
+        graphClipboard: MutableRefObject<ReturnType<typeof useGraphClipboard>>;
+    };
+    actions: {
+        setDecisionGraph: (val: Partial<DecisionGraphType>, options?: SetDecisionGraphOptions) => void;
+        undo: () => void;
+        redo: () => void;
+        commitUndo: () => void;
+        handleNodesChange: (nodesChange: NodeChange[]) => void;
+        handleEdgesChange: (edgesChange: EdgeChange[]) => void;
+        setNodes: (nodes: DecisionNode[]) => void;
+        addNodes: (nodes: DecisionNode[]) => void;
+        updateNode: (id: string, updater: DraftUpdateCallback<DecisionNode>) => void;
+        removeNodes: (ids: string[]) => void;
+        duplicateNodes: (ids: string[]) => void;
+        copyNodes: (ids: string[]) => void;
+        pasteNodes: () => void;
+        setEdges: (edges: DecisionEdge[]) => void;
+        addEdges: (edge: DecisionEdge[]) => void;
+        removeEdges: (ids: string[]) => void;
+        removeEdgeByHandleId: (handleId: string) => void;
+        setHoveredEdgeId: (edgeId: string | null) => void;
+        closeTab: (id: string, action?: string) => void;
+        openTab: (id: string) => void;
+        goToNode: (id: string) => void;
+        setActivePanel: (panel?: string) => void;
+        setCompactMode: (mode: boolean) => void;
+        toggleCompactMode: () => void;
+        setNodeType: (id: string, kind: NodeTypeKind, vt: VariableType) => void;
+        removeNodeType: (id: string, kind?: NodeTypeKind) => void;
+        setSimulatorRequest: (req: string) => void;
+        setSimulatorExampleBinding: (binding?: SimulatorExampleBinding) => void;
+        triggerNodeSelect: (id: string, mode: 'toggle' | 'only') => void;
+    };
+    listeners: {
+        onChange?: (val: DecisionGraphType) => void;
+        onPanelsChange?: (val?: string) => void;
+        onReactFlowInit?: (instance: ReactFlowInstance) => void;
+        onCodeExtension?: CodeEditorProps['extension'];
+        onFunctionReady?: (monaco: Monaco) => void;
+        onViewConfigCta?: () => void;
+    };
+};
+
+export declare type DecisionGraphType = {
+    nodes: DecisionNode[];
+    edges: DecisionEdge[];
+};
+
+declare type DecisionGraphWrapperProps = {
+    reactFlowProOptions?: ProOptions;
+    tabBarExtraContent?: GraphTabsProps['tabBarExtraContent'];
+    toolbarItems?: ToolbarItem[];
+    userResolver?: UserResolver;
+    customFunctions?: any;
+};
+
+export declare const decisionModelSchema: z.ZodObject<{
+    nodes: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<NodeKind.Decision>;
+        content: z.ZodObject<{
+            key: z.ZodString;
+            passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+            inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+            outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+            executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                single: "single";
+                loop: "loop";
+            }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+        }, z.core.$strip>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<NodeKind.Expression>;
+        content: z.ZodObject<{
+            expressions: z.ZodArray<z.ZodObject<{
+                id: z.ZodDefault<z.ZodString>;
+                key: z.ZodDefault<z.ZodString>;
+                value: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+            passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+            inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+            outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+            executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                single: "single";
+                loop: "loop";
+            }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+        }, z.core.$strip>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<NodeKind.Function>;
+        content: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodObject<{
+            source: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>]>>>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<NodeKind.DecisionTable>;
+        content: z.ZodObject<{
+            hitPolicy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                first: "first";
+                collect: "collect";
+            }>>>, z.ZodTransform<"first" | "collect", "first" | "collect" | null | undefined>>;
+            rules: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>>>>;
+            inputs: z.ZodArray<z.ZodObject<{
+                id: z.ZodDefault<z.ZodString>;
+                name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                defaultValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                fieldType: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"any">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"string">;
+                    enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"inline">;
+                        values: z.ZodArray<z.ZodObject<{
+                            label: z.ZodString;
+                            value: z.ZodString;
+                        }, z.core.$strip>>;
+                        loose: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"ref">;
+                        ref: z.ZodString;
+                        loose: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>], "type">>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"number">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"boolean">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"date">;
+                }, z.core.$strip>], "type">>>;
+            }, z.core.$strip>>;
+            outputs: z.ZodArray<z.ZodObject<{
+                id: z.ZodDefault<z.ZodString>;
+                name: z.ZodString;
+                field: z.ZodString;
+                defaultValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                outputFieldType: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"auto">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"string">;
+                    enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"inline">;
+                        values: z.ZodArray<z.ZodObject<{
+                            label: z.ZodString;
+                            value: z.ZodString;
+                        }, z.core.$strip>>;
+                        loose: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"ref">;
+                        ref: z.ZodString;
+                        loose: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>], "type">>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"string-array">;
+                    enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"inline">;
+                        values: z.ZodArray<z.ZodObject<{
+                            label: z.ZodString;
+                            value: z.ZodString;
+                        }, z.core.$strip>>;
+                        loose: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"ref">;
+                        ref: z.ZodString;
+                        loose: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>], "type">>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"number">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"boolean">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"date">;
+                }, z.core.$strip>], "type">>>;
+            }, z.core.$strip>>;
+            passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+            inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+            outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+            executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                single: "single";
+                loop: "loop";
+            }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+        }, z.core.$strip>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<NodeKind.Switch>;
+        content: z.ZodObject<{
+            hitPolicy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                first: "first";
+                collect: "collect";
+            }>>>, z.ZodTransform<"first" | "collect", "first" | "collect" | null | undefined>>;
+            statements: z.ZodArray<z.ZodObject<{
+                id: z.ZodDefault<z.ZodString>;
+                condition: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+                isDefault: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"customNode">;
+        content: z.ZodObject<{
+            kind: z.ZodString;
+            config: z.ZodAny;
+        }, z.core.$strip>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<NodeKind.Input>;
+        content: z.ZodDefault<z.ZodObject<{
+            schema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>>, z.ZodTransform<string, string | Record<string, any> | null | undefined>>;
+            expressions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodDefault<z.ZodString>;
+                key: z.ZodDefault<z.ZodString>;
+                value: z.ZodDefault<z.ZodAny>;
+                type: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+            outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        }, z.core.$strip>>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<NodeKind.Output>;
+        content: z.ZodDefault<z.ZodObject<{
+            schema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+        }, z.core.$strip>>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "type">, z.ZodObject<{
+        type: z.ZodString;
+        content: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        position: z.ZodDefault<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>>>;
+    edges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        targetId: z.ZodString;
+        sourceHandle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        type: z.ZodEnum<{
+            edge: "edge";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+export declare type DecisionNode<T = any> = {
+    id: string;
+    name: string;
+    description?: string;
+    type?: NodeSchema['type'] | string;
+    content?: T;
+    position: Position;
+    [privateSymbol]?: {
+        dimensions?: {
+            height?: number;
+            width?: number;
+        };
+        selected?: boolean;
+    };
+    _diff?: {
+        status: DiffStatus;
+        fields?: Record<string, DiffMetadata>;
+    };
+};
+
+export declare const decisionNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Decision>;
+    content: z.ZodObject<{
+        key: z.ZodString;
+        passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            single: "single";
+            loop: "loop";
+        }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+export declare const DecisionTable: default_2.FC<DecisionTableProps>;
+
+declare type DecisionTableContextProps = {};
+
+declare type DecisionTableEmptyType = {
+    id?: string;
+    name?: string;
+    defaultValue?: DecisionTableType;
+    value?: DecisionTableType;
+    disabled?: boolean;
+    disableHitPolicy?: boolean;
+    cellRenderer?: (props: TableCellProps) => default_2.JSX.Element | null | undefined;
+    inputsSchema?: SchemaSelectProps[];
+    outputsSchema?: SchemaSelectProps[];
+    permission?: DecisionTableStoreType['state']['permission'];
+    mode?: JdmUiMode;
+    dictionaries?: DictionaryMap;
+    inputVariableType?: VariableType;
+    debug?: {
+        trace: SimulationTrace<SimulationTraceDataTable>;
+        inputData?: GetNodeDataResult;
+        snapshot: DecisionTableType;
+    };
+    minColWidth?: number;
+    colWidth?: number;
+    onChange?: (val: DecisionTableType) => void;
+};
+
+export declare type DecisionTableMode = JdmUiMode;
+
+declare type DecisionTablePermission = 'edit:full' | 'edit:rules' | 'edit:values';
+
+export declare type DecisionTableProps = {
+    id?: string;
+    tableHeight: string | number;
+    mountDialogsOnBody?: boolean;
+    scrollContainerRef?: default_2.MutableRefObject<HTMLDivElement | null>;
+    scrollApiRef?: default_2.MutableRefObject<TableScrollApi | null>;
+} & DecisionTableContextProps & DecisionTableEmptyType;
+
+export declare const decisionTableSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.DecisionTable>;
+    content: z.ZodObject<{
+        hitPolicy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            first: "first";
+            collect: "collect";
+        }>>>, z.ZodTransform<"first" | "collect", "first" | "collect" | null | undefined>>;
+        rules: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>>>>;
+        inputs: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            defaultValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            fieldType: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"any">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"string">;
+                enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"inline">;
+                    values: z.ZodArray<z.ZodObject<{
+                        label: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"ref">;
+                    ref: z.ZodString;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"number">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"boolean">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"date">;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>>;
+        outputs: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            name: z.ZodString;
+            field: z.ZodString;
+            defaultValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            outputFieldType: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"auto">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"string">;
+                enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"inline">;
+                    values: z.ZodArray<z.ZodObject<{
+                        label: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"ref">;
+                    ref: z.ZodString;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"string-array">;
+                enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"inline">;
+                    values: z.ZodArray<z.ZodObject<{
+                        label: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"ref">;
+                    ref: z.ZodString;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"number">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"boolean">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"date">;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>>;
+        passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            single: "single";
+            loop: "loop";
+        }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare type DecisionTableStoreType = {
+    state: {
+        id?: string;
+        name?: string;
+        decisionTable: DecisionTableType;
+        cursor: TableCursor | null;
+        disabled: boolean;
+        disableHitPolicy: boolean;
+        minColWidth: number;
+        colWidth: number;
+        permission?: DecisionTablePermission;
+        mode: JdmUiMode;
+        dictionaries?: DictionaryMap;
+        inputVariableType?: VariableType;
+        derivedVariableTypes: Record<string, VariableType>;
+        inputsSchema?: SchemaSelectProps[];
+        outputsSchema?: SchemaSelectProps[];
+        debugIndex: number;
+        calculatedInputData?: Variable;
+        debug?: {
+            snapshot: DecisionTableType;
+            trace: SimulationTrace<SimulationTraceDataTable>;
+            inputData?: GetNodeDataResult;
+        };
+    };
+    actions: {
+        setDecisionTable: (val: DecisionTableType) => void;
+        setCursor: (cursor: TableCursor | null) => void;
+        commitData: (data: string, cursor: TableCursor) => void;
+        swapRows: (source: number, target: number) => void;
+        addRowAbove: (target?: number) => void;
+        addRowBelow: (target?: number) => void;
+        removeRow: (target?: number) => void;
+        addColumn: (type: ColumnType, column: TableSchemaItem) => void;
+        updateColumn: (type: ColumnType, id: string, column: TableSchemaItem) => void;
+        removeColumn: (type: ColumnType, id: string) => void;
+        reorderColumns: (type: ColumnType, columns: TableSchemaItem[]) => void;
+        updateHitPolicy: (hitPolicy: HitPolicy) => void;
+    };
+    listeners: {
+        onChange?: (val: DecisionTableType) => void;
+        cellRenderer?: (props: TableCellProps) => default_2.ReactNode | null | undefined;
+        onColumnResize?: () => void;
+    };
+};
+
+export declare type DecisionTableType = {
+    hitPolicy: HitPolicy | string;
+    passThrough?: boolean;
+    inputField?: string;
+    outputPath?: string;
+    executionMode?: 'single' | 'loop';
+    inputs: TableSchemaItem[];
+    outputs: TableSchemaItem[];
+    rules: Record<string, string>[];
+} & Diff;
+
+export declare type DictionaryMap = Record<string, {
+    label: string;
+    value: string;
+}[]>;
+
+export declare const DictionaryProvider: default_2.FC<default_2.PropsWithChildren<{
+    value: DictionaryMap;
+}>>;
+
+export declare type Diff<T = any> = {
+    _diff?: DiffMetadata<T>;
+};
+
+export declare const DiffAutosizeTextArea: default_2.ForwardRefExoticComponent<Omit<DiffAutosizeTextAreaProps, "ref"> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare type DiffAutosizeTextAreaProps = AutosizeTextAreaProps & {
+    previousValue?: string;
+    displayDiff?: boolean;
+    noStyle?: boolean;
+};
+
+export declare const DiffCodeEditor: default_2.ForwardRefExoticComponent<{
+    maxRows?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    onStateChange?: (state: EditorState) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    type?: "unary" | "standard" | "template";
+    lint?: boolean;
+    strict?: boolean;
+    fullHeight?: boolean;
+    noStyle?: boolean;
+    extension?: (params: {
+        type?: "standard" | "unary" | "template";
+    }) => Extension;
+    livePreview?: {
+        input: unknown;
+        fromSimulation: boolean;
+        result?: unknown;
+    };
+    variableType?: any;
+    expectedVariableType?: any;
+    lazy?: boolean;
+    initialSelection?: {
+        anchor: number;
+        head?: number;
+    };
+} & Omit<default_2.HTMLAttributes<HTMLDivElement>, "disabled" | "onChange"> & {
+    lazy?: boolean;
+} & {
+    displayDiff?: boolean;
+    previousValue?: string;
+    noStyle?: boolean;
+} & default_2.RefAttributes< CodeEditorBaseRef>>;
+
+export declare type DiffCodeEditorProps = CodeEditorProps & {
+    displayDiff?: boolean;
+    previousValue?: string;
+    noStyle?: boolean;
+};
+
+export declare const DiffIcon: default_2.FC<{
+    status?: DiffStatus;
+    style?: default_2.CSSProperties;
+    className?: string;
+}>;
+
+export declare const DiffInput: default_2.FC<DiffInputProps>;
+
+export declare type DiffInputProps = InputProps & {
+    previousValue?: string;
+    displayDiff?: boolean;
+};
+
+export declare type DiffMetadata<T = any> = {
+    status?: DiffStatus;
+    previousValue?: T;
+    previousIndex?: number;
+    currentIndex?: number;
+    fields?: Record<string, DiffMetadata>;
+};
+
+declare interface DiffOptions<T extends BaseItem> {
+    idField?: 'id' | '_id';
+    compareFields?: (current: T, previous: T) => {
+        hasChanges: boolean;
+        fields?: Record<string, DiffMetadata>;
+    };
+}
+
+export declare const DiffRadio: default_2.FC<DiffRadioProps>;
+
+export declare type DiffRadioProps = {
+    previousValue?: string;
+    displayDiff?: boolean;
+} & RadioGroupProps;
+
+export declare const DiffSelect: default_2.FC<DiffSelectProps>;
+
+export declare type DiffSelectProps = Omit<SelectProps, 'direction'> & {
+    previousValue?: string;
+    displayDiff?: boolean;
+    direction?: SpaceProps['direction'];
+};
+
+export declare type DiffStatus = 'added' | 'removed' | 'modified' | 'unchanged' | 'moved';
+
+export declare const DiffSwitch: default_2.FC<DiffSwitchProps>;
+
+export declare type DiffSwitchProps = {
+    previousChecked?: boolean;
+    displayDiff?: boolean;
+} & SwitchProps;
+
+declare type DraftUpdateCallback<T> = (draft: WritableDraft<T>) => WritableDraft<T>;
+
+export declare const edgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    sourceHandle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodEnum<{
+        edge: "edge";
+    }>;
+}, z.core.$strip>;
+
+declare const en: {
+    readonly 'common.ok': "OK";
+    readonly 'common.cancel': "Cancel";
+    readonly 'common.remove': "Remove";
+    readonly 'common.delete': "Delete";
+    readonly 'common.retry': "Retry";
+    readonly 'common.close': "Close";
+    readonly 'common.update': "Update";
+    readonly 'common.create': "Create";
+    readonly 'common.convert': "Convert";
+    readonly 'common.format': "Format";
+    readonly 'common.recover': "Recover";
+    readonly 'common.copy': "Copy";
+    readonly 'dt.toolbar.import': "Import Excel";
+    readonly 'dt.toolbar.export': "Export Excel";
+    readonly 'dt.toolbar.addRowAbove': "Add row above";
+    readonly 'dt.toolbar.addRowBelow': "Add row below";
+    readonly 'dt.toolbar.removeRow': "Remove row";
+    readonly 'dt.toolbar.removeRowConfirm': "Remove row?";
+    readonly 'dt.table.column': "Table column";
+    readonly 'dt.table.excelColumn': "Excel column";
+    readonly 'dt.table.selectExcelColumn': "Select Excel column";
+    readonly 'dt.table.description': "Description";
+    readonly 'dt.table.selectDescription': "Select Excel column for description";
+    readonly 'dt.table.reorderFields': "Reorder fields";
+    readonly 'dt.field.input.add': "Add Input";
+    readonly 'dt.field.input.label': "Input Field";
+    readonly 'dt.field.output.add': "Add Output";
+    readonly 'dt.field.output.label': "Output Field";
+    readonly 'dt.field.label': "Field label";
+    readonly 'dt.field.name': "Name";
+    readonly 'dt.field.type': "Field Type";
+    readonly 'dt.field.outputType': "Output Type";
+    readonly 'dt.field.editColumn': "Edit column";
+    readonly 'dt.field.removeColumn': "Remove column";
+    readonly 'dt.field.removeConfirm': "Remove this column?";
+    readonly 'dt.field.wrapQuotes': "Wrap values in quotes";
+    readonly 'dt.field.selectDictionary': "Select dictionary...";
+    readonly 'dt.field.allowCustomValues': "Allow custom values";
+    readonly 'dt.toolbar.simulationIndex': "Simulation index:";
+    readonly 'dt.excel.title': "Map Excel data";
+    readonly 'dt.excel.input': "Input";
+    readonly 'dt.excel.output': "Output";
+    readonly 'dt.excel.enterFieldName': "Enter field name";
+    readonly 'dg.node.decisionTables': "Decision Tables";
+    readonly 'dg.node.expressions': "Expressions";
+    readonly 'dg.node.functions': "Functions";
+    readonly 'dg.node.editExpression': "Edit Expression";
+    readonly 'vh.title': "Version history";
+    readonly 'vh.description.some': "{{count}} version(s). Restoring loads that version as the current one.";
+    readonly 'vh.description.none': "No versions yet. Each save creates one.";
+    readonly 'vh.loading': "Loading…";
+    readonly 'vh.filter.label': "Filter versions";
+    readonly 'vh.filter.placeholder': "Filter by name or revision…";
+    readonly 'vh.filter.noMatch': "No versions match \"{{query}}\".";
+    readonly 'vh.noChanges': "No changes";
+    readonly 'vh.changes': "changes";
+    readonly 'vh.entry.current': "current";
+    readonly 'vh.entry.auto': "auto";
+    readonly 'vh.entry.pinned': "pinned";
+    readonly 'vh.restore': "Restore";
+    readonly 'vh.rename.title': "Rename version";
+    readonly 'vh.rename.aria': "Rename version {{revision}}";
+    readonly 'vh.name.aria': "Name version {{revision}}";
+    readonly 'vh.name.placeholder': "Version name";
+    readonly 'vh.name.button': "Name";
+    readonly 'vh.pin.title': "Pin version";
+    readonly 'vh.pin.aria': "Pin version {{revision}}";
+    readonly 'vh.unpin.title': "Unpin version";
+    readonly 'vh.unpin.aria': "Unpin version {{revision}}";
+    readonly 'vh.compare.button': "Compare";
+    readonly 'vh.compare.title': "Compare against this version on the canvas";
+    readonly 'vh.compare.aria': "Compare against version {{revision}}";
+    readonly 'vh.compare.exit.button': "Exit compare";
+    readonly 'vh.compare.exit.title': "Exit compare mode";
+    readonly 'vh.compare.exit.aria': "Exit compare (was against {{revision}})";
+    readonly 'vh.compare.entry': "comparing";
+    readonly 'dg.toolbar.uploadJson': "Upload JSON";
+    readonly 'dg.toolbar.uploadExcel': "Upload Excel";
+    readonly 'dg.toolbar.downloadJson': "Download JSON";
+    readonly 'dg.toolbar.downloadExcel': "Download Excel";
+    readonly 'dg.toolbar.searchNodes': "Search nodes";
+    readonly 'dg.toolbar.closeClose': "Close panel";
+    readonly 'dg.toolbar.schema': "JSON Schema";
+    readonly 'dg.tabs.close': "Close";
+    readonly 'dg.tabs.closeAll': "Close all Tabs";
+    readonly 'dg.tabs.closeOthers': "Close other Tabs";
+    readonly 'dg.tabs.closeRight': "Close Tabs to the right";
+    readonly 'dg.tabs.closeLeft': "Close Tabs to the left";
+    readonly 'dg.jsonSchema.title': "Convert to JSON Schema";
+    readonly 'dg.jsonSchema.copyJson': "Copy JSON";
+    readonly 'dg.node.documentation': "Documentation";
+    readonly 'dg.node.duplicate': "Duplicate";
+    readonly 'dg.node.deleteNode': "Delete node";
+    readonly 'dg.schema.formatCode': "Format code";
+    readonly 'dg.schema.importFromJson': "Import from JSON";
+    readonly 'dg.excel.wrapQuotes': "Wrap value in quotes";
+    readonly 'dg.excel.enterFieldName': "Enter field name";
+    readonly 'dg.condition.removeConfirm': "Remove condition?";
+    readonly 'expression.placeholder': "Expression";
+    readonly 'expression.key': "Key";
+    readonly 'expression.addRowAbove': "Add row above";
+    readonly 'expression.addRowBelow': "Add row below";
+    readonly 'func.debugger.copy': "Copy to clipboard";
+    readonly 'func.debugger.copied': "Copied to clipboard";
+    readonly 'func.debugger.formatCode': "Format code";
+    readonly 'func.debugger.importLibrary': "Import library";
+    readonly 'func.debugger.goToDocs': "Go to documentation";
+    readonly 'func.debugger.msSinceRun': "Time since start of execution of script.";
+    readonly 'misc.search': "Search...";
+    readonly 'func.preview.noResults': "Run simulation to see the results";
+    readonly 'safe.title': "Something went wrong";
+    readonly 'safe.retry': "Retry";
+    readonly request: "Request";
+    readonly 'request.dataLabel': "Example data";
+    readonly 'request.dataSourceSaved': "Data saved";
+    readonly 'request.dataTypeMismatchWarning': "The current request data type does not match the definitions. To change the definition, update it in Definitions.";
+    readonly 'request.downloadJsonNoData': "No data available to download";
+    readonly 'request.jsonInvalidError': "Enter valid JSON or JSON5";
+    readonly 'request.jsonObjectError': "Enter a JSON object";
+    readonly 'request.saveDataSourceFailed': "Failed to save data";
+    readonly 'request.selectDataSourceFirst': "Select a data first";
+    readonly 'request.typeArray': "Array";
+    readonly 'request.typeBoolean': "Boolean";
+    readonly 'request.typeDatetime': "Datetime";
+    readonly 'request.typeNumber': "Number";
+    readonly 'request.typeObject': "Object";
+    readonly 'request.typeString': "String";
+    readonly 'request.uploadJsonFailed': "Failed to upload JSON";
+    readonly 'request.uploadJsonObjectRequired': "Uploaded JSON must be an object";
+    readonly 'request.uploadJsonSuccess': "JSON uploaded successfully";
+    readonly 'request.key': "Key";
+    readonly 'request.type': "Type";
+    readonly 'request.description': "Description";
+    readonly 'request.save': "Save";
+    readonly 'request.schema': "Schema";
+    readonly 'request.addChildField': "Add child field";
+    readonly 'request.addDataSource': "Add data";
+    readonly 'request.addField': "Add field";
+    readonly 'request.childFieldNamePlaceholder': "Child field name";
+    readonly 'request.createDataSource': "Create data";
+    readonly 'request.definitionsTab': "Definitions";
+    readonly 'request.deleteDataSourceConfirm': "Delete this data?";
+    readonly 'request.deleteFieldConfirm': "Delete this field?";
+    readonly 'request.downloadJsonTooltip': "Download JSON for the current data ";
+    readonly 'request.exampleDescriptionPlaceholder': "Add example description...";
+    readonly 'request.exampleFieldSummary': "Field summary";
+    readonly 'request.exampleFieldSummaryAllMatch': "Fields match definitions";
+    readonly 'request.exampleFieldSummaryConflicts': "Type conflicts";
+    readonly 'request.exampleFieldSummaryDefinitions': "Defined fields";
+    readonly 'request.exampleFieldSummaryExtra': "Extra fields";
+    readonly 'request.exampleFieldSummaryMissing': "Missing fields";
+    readonly 'request.examplesTab': "Data";
+    readonly 'request.fieldDefaultValuePlaceholder': "Default value";
+    readonly 'request.fieldDescriptionPlaceholder': "Field description";
+    readonly 'request.fieldNamePlaceholder': "Field name";
+    readonly 'request.formatSchema': "Format schema";
+    readonly 'request.noDataSources': "No data";
+    readonly 'request.noDefinitions': "No field definitions";
+    readonly 'request.schemaPriorityTooltip': "Schema has the highest priority. Definitions and example data sync into schema, but schema remains the source of truth.";
+    readonly 'request.simulateTooltip': "Open simulator";
+    readonly 'request.toggleFieldDescriptionsTooltip': "Toggle field description hints";
+    readonly 'request.uploadJsonTooltip': "Upload JSON for the current data";
+    readonly 'cf.key': "Key";
+    readonly 'cf.expression': "Expression";
+    readonly 'cf.function': "Function";
+    readonly 'cf.code': "Code";
+    readonly 'cf.legacy': "Legacy";
+    readonly 'cf.addRow': "Add Row";
+    readonly 'simulator.boundRequestNodeNotFound': "Bound request node not found";
+    readonly 'simulator.requestMustBeObjectToSave': "The current request must be a JSON object to save";
+    readonly 'simulator.description': "Your business context that enters through the Request node, starting the decision process. Supply JSON or JSON5 format.";
+    readonly 'simulator.currentBinding': "Current binding";
+    readonly 'simulator.nodeRequired': "Request node is required to run the graph. Drag-and-drop it from the Components panel.";
+    readonly 'simulator.run': "Run";
+    readonly 'simulator.formatSuccess': "Formatted successfully!";
+    readonly 'simulator.formatFailed': "Failed to format. Invalid JSON format.";
+    readonly 'simulator.nothingToCopy': "Nothing to copy.";
+    readonly 'simulator.copiedToClipboard': "Copied to clipboard!";
+    readonly 'simulator.copyFailedInvalidJson': "Failed to copy. Invalid JSON format.";
+    readonly 'simulator.dataRequiredBeforeRun': "The current request is empty. Please add example data first.";
+    readonly 'simulator.invalidFormatTitle': "Invalid request format";
+    readonly 'simulator.invalidFormatDescription': "Enter a valid JSON or JSON5 object before running.";
+    readonly 'simulator.searchPlaceholder': "Search nodes...";
+    readonly 'simulator.clear': "Clear";
+    readonly 'simulator.readyTitle': "Ready to simulate!";
+    readonly 'simulator.readyHint': "Run a request to see the node trace in action.";
+    readonly 'simulator.learnMore': "Learn more";
+    readonly 'common.clear': "Clear";
+    readonly 'misc.delete': "Delete";
+};
+
+export declare const ensureWasmLoaded: () => Promise<void>;
+
+declare type ExposedStore<T> = UseBoundStore<StoreApi<T>> & {
+    setState: (partial: Partial<T>) => void;
+};
+
+export declare const Expression: default_2.FC<ExpressionProps>;
+
+export declare const ExpressionBuilder: default_2.ForwardRefExoticComponent<ExpressionBuilderProps & default_2.RefAttributes<ExpressionBuilderRef>>;
+
+export declare type ExpressionBuilderProps = {
+    value: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    fieldType?: ColumnFieldType;
+    maxRows?: number;
+};
+
+export declare type ExpressionBuilderRef = {
+    focus: () => void;
+};
+
+declare type ExpressionControllerProps = {
+    disabled?: boolean;
+    defaultValue?: ExpressionEntry[];
+    permission?: ExpressionStore['permission'];
+    value?: ExpressionEntry[];
+    onChange?: (value: ExpressionEntry[]) => void;
+};
+
+declare type ExpressionDebug = {
+    snapshot: z.infer<typeof expressionNodeSchema>['content'];
+    trace: SimulationTrace<SimulationTraceDataExpression>;
+    inputData?: GetNodeDataResult;
+};
+
+declare type ExpressionEntry = {
+    id: string;
+    key: string;
+    value: string;
+    _diff?: DiffMetadata;
+};
+
+export declare const expressionNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Expression>;
+    content: z.ZodObject<{
+        expressions: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            key: z.ZodDefault<z.ZodString>;
+            value: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            single: "single";
+            loop: "loop";
+        }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare type ExpressionPermission = 'edit:full' | 'edit:values' | 'view';
+
+export declare type ExpressionProps = {
+    inputVariableType?: VariableType;
+    debug?: ExpressionDebug;
+    hideCommandBar?: boolean;
+} & ExpressionControllerProps;
+
+declare type ExpressionStore = {
+    disabled: boolean;
+    permission?: ExpressionPermission;
+    addRowAbove: (index?: number, data?: Partial<ExpressionEntry>) => void;
+    addRowBelow: (index?: number, data?: Partial<ExpressionEntry>) => void;
+    expressions: ExpressionEntry[];
+    setExpressions: (expressions: ExpressionEntry[]) => void;
+    swapRows: (sourceIndex: number, targetIndex: number) => void;
+    updateRow: (index: number, update: Partial<Omit<ExpressionEntry, 'id'>>) => void;
+    removeRow: (index: number) => void;
+    inputVariableType?: VariableType;
+    debugIndex: number;
+    calculatedInputData?: Variable;
+    debug?: ExpressionDebug;
+};
+
+declare type ExtensionParams = {
+    type?: 'standard' | 'unary' | 'template';
+};
+
+declare const Function_2: default_2.FC<FunctionProps>;
+export { Function_2 as Function }
+
+declare type FunctionLibrary = {
+    name: string;
+    tagline: string;
+    typeDef: string;
+    importName?: string;
+    documentationUrl?: string;
+};
+
+export declare const functionNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Function>;
+    content: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        source: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+export declare type FunctionPermission = 'edit:full';
+
+export declare type FunctionProps = {
+    disabled?: boolean;
+    defaultValue?: string;
+    disableDebug?: boolean;
+    language?: string;
+    value?: string;
+    previousValue?: string;
+    onChange?: (value: string) => void;
+    trace?: SimulationTrace<SimulationTraceDataFunction>;
+    onMonacoReady?: (monaco: Monaco) => void;
+    onEditorMount?: (editor: editor.IStandaloneCodeEditor) => void;
+    libraries?: FunctionLibrary[];
+    inputData?: unknown;
+    permission?: FunctionPermission;
+    error?: {
+        data: {
+            nodeId: string;
+            source?: string;
+        };
+    };
+};
+
+declare type GenerateNodeParams = {
+    index: number;
+};
+
+declare type GenerateNodeParams_2 = {
+    index: number;
+};
+
+declare type GetNodeDataResult = {
+    data: unknown;
+    $nodes: unknown;
+    $?: unknown;
+};
+
+export declare const getRequestDefinitions: (content?: RequestContentLike | null) => RequestDefinition[];
+
+export declare const getRequestExampleSources: (content?: RequestContentLike | null, options?: {
+    dataLabel?: string;
+}) => RequestExampleSource[];
+
+export declare const getRequestSchemaSourceValue: (content?: RequestContentLike | null) => unknown;
+
+export declare const GraphDecisionNode: default_2.FC<GraphDecisionNodeProps>;
+
+export declare type GraphDecisionNodeProps = {
+    name?: string;
+    icon: default_2.ReactNode;
+    type: default_2.ReactNode;
+    helper?: (default_2.ReactNode | false)[];
+    disabled?: boolean;
+    isSelected?: boolean;
+    children?: default_2.ReactNode;
+    actions?: default_2.ReactNode[];
+    status?: 'error' | 'success' | 'warning';
+    diffStatus?: 'removed' | 'added' | 'modified' | 'moved';
+    noBodyPadding?: boolean;
+    color?: 'primary' | 'secondary' | string;
+    menuItems?: MenuProps['items'];
+    onNameChange?: (name: string) => void;
+    compactMode?: boolean;
+    listMode?: boolean;
+    details?: default_2.ReactNode;
+    detailsOpen?: boolean;
+    detailsTitle?: string;
+    onDetailsClose?: () => void;
+};
+
+export declare type GraphDiff = {
+    addedNodes: GraphNodeChange[];
+    removedNodes: GraphNodeChange[];
+    modifiedNodes: GraphNodeChange[];
+    addedEdges: GraphNodeChange[];
+    removedEdges: GraphNodeChange[];
+    modifiedEdges: GraphNodeChange[];
+    unchanged: boolean;
+};
+
+export declare const GraphNode: default_2.ForwardRefExoticComponent<{
+    id: string;
+    handleLeft?: boolean | Partial<HandleProps>;
+    handleRight?: boolean | Partial<HandleProps>;
+    className?: string;
+    specification: MinimalNodeSpecification;
+    displayError?: boolean;
+} & Partial<GraphDecisionNodeProps> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare type GraphNodeChange = {
+    id: string;
+    name?: string;
+    kind?: string;
+    fields?: string[];
+};
+
+export declare type GraphNodeProps = {
+    id: string;
+    handleLeft?: boolean | Partial<HandleProps>;
+    handleRight?: boolean | Partial<HandleProps>;
+    className?: string;
+    specification: MinimalNodeSpecification;
+    displayError?: boolean;
+} & Partial<GraphDecisionNodeProps>;
+
+declare type GraphRef = DecisionGraphStoreType['actions'] & {
+    stateStore: ExposedStore<DecisionGraphStoreType['state']>;
+    serialize: () => DecisionGraphSnapshot;
+    restore: (snapshot: DecisionGraphSnapshot) => void;
+};
+
+export declare const GraphSimulator: default_2.FC<GraphSimulatorProps>;
+
+export declare type GraphSimulatorProps = {
+    onClear?: () => void;
+    loading?: boolean;
+    defaultRequest?: SimulatorRequestPanelProps['defaultRequest'];
+    onChange?: SimulatorRequestPanelProps['onChange'];
+    onRun?: SimulatorRequestPanelProps['onRun'];
+    leftPanel?: default_2.FC<SimulatorRequestPanelProps>;
+};
+
+declare type GraphTabsProps = {
+    disabled?: boolean;
+    tabBarExtraContent?: TabsProps['tabBarExtraContent'];
+};
+
+declare type HitPolicy = 'first' | 'collect';
+
+export declare type I18nMessages = Record<string, string>;
+
+export declare const I18nProvider: React_2.FC<{
+    locale: string;
+    overrides?: I18nMessages;
+    children: React_2.ReactNode;
+}>;
+
+declare type InferredContent = z.infer<typeof inputNodeSchema>['content'];
+
+declare type InferredContent_2 = z.infer<typeof outputNodeSchema>['content'];
+
+declare type InferredContent_3 = z.infer<typeof decisionTableSchema>['content'];
+
+declare type InferredContent_4 = z.infer<typeof expressionNodeSchema>['content'];
+
+declare type InferTypeData<T> = {
+    input: VariableType;
+    content: T;
+};
+
+declare type Input = unknown;
+
+export declare const inputNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Input>;
+    content: z.ZodDefault<z.ZodObject<{
+        schema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>>, z.ZodTransform<string, string | Record<string, any> | null | undefined>>;
+        expressions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            key: z.ZodDefault<z.ZodString>;
+            value: z.ZodDefault<z.ZodAny>;
+            type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+    }, z.core.$strip>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare interface InputProps extends Omit<React_2.InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix' | 'suffix'> {
+    size?: 'large' | 'middle' | 'small';
+    allowClear?: boolean;
+    bordered?: boolean;
+    prefix?: React_2.ReactNode;
+    suffix?: React_2.ReactNode;
+}
+
+declare type InputSchema<Name extends string> = {
+    name: Name;
+} & (BoolInput | TextInput);
+
+declare type InputTypeMap = {
+    bool: boolean;
+    text: string;
+};
+
+declare type InterpolationParams = Record<string, string | number>;
+
+export declare const JdmConfigProvider: default_2.FC<JdmConfigProviderProps>;
+
+export declare type JdmConfigProviderProps = {
+    theme?: ThemeConfig;
+    seeds?: ThemeSeeds;
+    locale?: string;
+    messages?: Record<string, string>;
+    prefixCls?: string;
+    dictionaries?: DictionaryMap;
+    children?: default_2.ReactNode;
+};
+
+export declare type JdmUiMode = 'dev' | 'business';
+
+declare type JsonSchema = {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema | JsonSchema[];
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    nullable?: boolean;
+};
+
+export declare const jsonSchemaToVariableType: (schema?: JsonSchema | null) => VariableType;
+
+declare type LegacyRequestInput = {
+    id?: string;
+    key?: string;
+    type?: string;
+    value?: unknown;
+    desc?: unknown;
+    description?: unknown;
+};
+
+export declare const lightTokens: Record<string, string | number>;
+
+declare interface MenuItemType {
+    key?: string;
+    label?: React_2.ReactNode;
+    icon?: React_2.ReactNode;
+    danger?: boolean;
+    disabled?: boolean;
+    type?: 'divider' | 'group';
+    onClick?: (info: {
+        key: string;
+    }) => void;
+    children?: MenuItemType[];
+}
+
+declare interface MenuProps {
+    items?: MenuItemType[];
+    onClick?: MenuItemType['onClick'];
+}
+
+export declare type MinimalNodeProps = Pick<NodeProps, 'id' | 'selected'> & {
+    data: any;
+};
+
+export declare type MinimalNodeSpecification = Pick<NodeSpecification, 'color' | 'icon' | 'displayName' | 'documentationUrl' | 'helper' | 'renderSettings'>;
+
+export declare const MODE_EXTRAS: Record<'light' | 'dark', {
+    borderHover: string;
+    borderFade: string;
+    primaryBgFade: string;
+}>;
+
+export declare enum NodeColor {
+    Blue = "var(--node-color-blue)",
+    Purple = "var(--node-color-purple)",
+    Orange = "var(--node-color-orange)",
+    Green = "var(--node-color-green)"
+}
+
+declare type NodeDecisionTableData = Omit<InferredContent_3, 'inputs' | 'outputs' | 'rules'> & Diff & {
+    rules: (InferredContent_3['rules'][0] & Diff)[];
+    inputs: (InferredContent_3['inputs'][0] & Diff)[];
+    outputs: (InferredContent_3['outputs'][0] & Diff)[];
+};
+
+declare type NodeExpressionData = Omit<InferredContent_4, 'expressions'> & Diff & {
+    expressions: (InferredContent_4['expressions'][0] & Diff)[];
+};
+
+declare type NodeFunctionData = string | {
+    source: string;
+};
+
+declare type NodeInputData = InferredContent & Diff;
+
+export declare enum NodeKind {
+    Input = "inputNode",
+    Output = "outputNode",
+    DecisionTable = "decisionTableNode",
+    Function = "functionNode",
+    Expression = "expressionNode",
+    Switch = "switchNode",
+    Decision = "decisionNode"
+}
+
+declare type NodeOutputData = InferredContent_2 & Diff;
+
+declare type NodeSchema = z.infer<typeof nodeSchema>;
+
+export declare const nodeSchema: z.ZodUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Decision>;
+    content: z.ZodObject<{
+        key: z.ZodString;
+        passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            single: "single";
+            loop: "loop";
+        }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Expression>;
+    content: z.ZodObject<{
+        expressions: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            key: z.ZodDefault<z.ZodString>;
+            value: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            single: "single";
+            loop: "loop";
+        }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Function>;
+    content: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        source: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.DecisionTable>;
+    content: z.ZodObject<{
+        hitPolicy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            first: "first";
+            collect: "collect";
+        }>>>, z.ZodTransform<"first" | "collect", "first" | "collect" | null | undefined>>;
+        rules: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>>>>;
+        inputs: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            defaultValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            fieldType: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"any">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"string">;
+                enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"inline">;
+                    values: z.ZodArray<z.ZodObject<{
+                        label: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"ref">;
+                    ref: z.ZodString;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"number">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"boolean">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"date">;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>>;
+        outputs: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            name: z.ZodString;
+            field: z.ZodString;
+            defaultValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            outputFieldType: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"auto">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"string">;
+                enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"inline">;
+                    values: z.ZodArray<z.ZodObject<{
+                        label: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"ref">;
+                    ref: z.ZodString;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"string-array">;
+                enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"inline">;
+                    values: z.ZodArray<z.ZodObject<{
+                        label: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"ref">;
+                    ref: z.ZodString;
+                    loose: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"number">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"boolean">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"date">;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>>;
+        passThrough: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        executionMode: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            single: "single";
+            loop: "loop";
+        }>>>, z.ZodTransform<"single" | "loop", "single" | "loop" | null | undefined>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Switch>;
+    content: z.ZodObject<{
+        hitPolicy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            first: "first";
+            collect: "collect";
+        }>>>, z.ZodTransform<"first" | "collect", "first" | "collect" | null | undefined>>;
+        statements: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            condition: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+            isDefault: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"customNode">;
+    content: z.ZodObject<{
+        kind: z.ZodString;
+        config: z.ZodAny;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Input>;
+    content: z.ZodDefault<z.ZodObject<{
+        schema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>>, z.ZodTransform<string, string | Record<string, any> | null | undefined>>;
+        expressions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            key: z.ZodDefault<z.ZodString>;
+            value: z.ZodDefault<z.ZodAny>;
+            type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        inputField: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+        outputPath: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>, z.ZodTransform<string | null, string | null>>;
+    }, z.core.$strip>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Output>;
+    content: z.ZodDefault<z.ZodObject<{
+        schema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+    }, z.core.$strip>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">, z.ZodObject<{
+    type: z.ZodString;
+    content: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
+
+export declare type NodeSpecification<T = any> = {
+    icon?: default_2.ReactNode;
+    type: string;
+    color?: GraphDecisionNodeProps['color'];
+    group?: string;
+    displayName: string | default_2.ReactNode;
+    documentationUrl?: string;
+    shortDescription?: string;
+    helper?: string | default_2.ReactNode;
+    renderTab?: (props: {
+        id: string;
+        user?: string;
+        customFunctions?: any;
+    }) => default_2.ReactNode;
+    getDiffContent?: (current: T, previous: T) => T;
+    generateNode: (params: GenerateNodeParams) => Omit<DecisionNode<T>, 'position' | 'id' | 'type'>;
+    renderNode: default_2.FC<MinimalNodeProps & {
+        specification: MinimalNodeSpecification;
+    }>;
+    renderSettings?: default_2.FC<{
+        id: string;
+    }>;
+    inferTypes?: {
+        needsUpdate: (content: T, prevContent: T) => boolean;
+        determineOutputType: (state: InferTypeData<T>) => VariableType;
+    };
+    onNodeAdd?: (node: DecisionNode<T>) => Promise<DecisionNode<T>>;
+};
+
+export declare const nodeSpecification: Readonly<{
+    inputNode: NodeSpecification< NodeInputData>;
+    outputNode: NodeSpecification< NodeOutputData>;
+    decisionTableNode: NodeSpecification< NodeDecisionTableData>;
+    expressionNode: NodeSpecification< NodeExpressionData>;
+    functionNode: NodeSpecification< NodeFunctionData>;
+    switchNode: NodeSpecification< NodeSwitchData>;
+}>;
+
+declare type NodeSwitchData = {
+    hitPolicy?: 'first' | 'collect';
+    statements?: (SwitchStatement & Diff)[];
+} & Diff;
+
+export declare enum NodeTypeKind {
+    Input = 0,
+    Output = 1,
+    InferredInput = 2,
+    InferredOutput = 3
+}
+
+declare type NodeTypeParams = {
+    attachGlobals?: boolean;
+    disabled?: boolean;
+};
+
+export declare const normalizeRequestDefinitionOrders: <T extends Pick<RequestDefinition, "order" | "parentPath">>(definitions: T[]) => T[];
+
+export declare const normalizeRequestFieldKey: (key: string) => string;
+
+export declare const normalizeRequestJsonKeys: (value: unknown) => unknown;
+
+declare type Output = unknown;
+
+export declare const OUTPUT_FIELD_TYPE_OPTIONS: {
+    value: OutputFieldType['type'];
+    label: string;
+}[];
+
+export declare type OutputFieldType = z.infer<typeof outputFieldTypeSchema>;
+
+export declare const outputFieldTypeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"auto">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"string">;
+    enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"inline">;
+        values: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        loose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ref">;
+        ref: z.ZodString;
+        loose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"string-array">;
+    enum: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"inline">;
+        values: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        loose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ref">;
+        ref: z.ZodString;
+        loose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"date">;
+}, z.core.$strip>], "type">;
+
+export declare const outputNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Output>;
+    content: z.ZodDefault<z.ZodObject<{
+        schema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+    }, z.core.$strip>>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare type PanelType = {
+    id: string;
+    icon: default_2.ReactNode;
+    title: string;
+    renderPanel?: () => default_2.ReactNode;
+    hideHeader?: boolean;
+    onClick?: () => void;
+};
+
+export declare type Position = {
+    x: number;
+    y: number;
+};
+
+declare const privateSymbol: unique symbol;
+
+export declare const processEdges: (currentEdges: DecisionEdge[], previousEdges: DecisionEdge[]) => any[];
+
+export declare const processNodes: (currentNodes: DecisionNode<any>[], previousNodes: DecisionNode<any>[], options?: ProcessNodesOptions) => any[];
+
+export declare type ProcessNodesOptions = {
+    components: NodeSpecification[];
+    customNodes: CustomNodeSpecification<object, any>[];
+};
+
+declare interface RadioGroupProps {
+    value?: string | number | boolean;
+    disabled?: boolean;
+    size?: 'large' | 'middle' | 'small';
+    options?: Array<{
+        label?: React_2.ReactNode;
+        value: string | number;
+        disabled?: boolean;
+    }>;
+    onChange?: (event: {
+        target: {
+            value: unknown;
+        };
+    }) => void;
+    className?: string;
+    style?: React_2.CSSProperties;
+}
+
+declare type RequestContentLike = {
+    schema?: unknown;
+    schemaUI?: unknown;
+    inputs?: LegacyRequestInput[];
+};
+
+export declare type RequestDefinition = {
+    id: string;
+    path: string;
+    name: string;
+    type: RequestDefinitionType;
+    description: string;
+    format: string;
+    order: number;
+    depth: number;
+    parentPath: string | null;
+    source: 'schema.properties' | 'content.inputs';
+    defaultValue?: string;
+};
+
+export declare type RequestDefinitionType = 'number' | 'string' | 'array' | 'object' | 'datetime' | 'boolean';
+
+declare type RequestExampleMeta = {
+    name?: string;
+    description?: string;
+};
+
+export declare type RequestExampleSource = {
+    id: string;
+    name: string;
+    description?: string;
+    data: Record<string, unknown>;
+    source: 'schema.examples' | 'content.inputs';
+};
+
+declare type RequestJsonSchema = {
+    'type'?: string | string[];
+    'description'?: string;
+    'format'?: string;
+    'properties'?: Record<string, RequestJsonSchema>;
+    'items'?: RequestJsonSchema | RequestJsonSchema[];
+    'examples'?: unknown[];
+    'x-examples-meta'?: RequestExampleMeta[];
+    'x-order'?: number;
+    [key: string]: unknown;
+};
+
+export declare const resolveRequestSchemaValue: (content?: RequestContentLike | null, options?: {
+    includeExamples?: boolean;
+}) => RequestJsonSchema | null;
+
+declare type SchemaSelectProps = {
+    field: string;
+    name?: string;
+    items?: SchemaSelectProps[];
+};
+
+declare interface SelectOption {
+    id?: string;
+    type?: string;
+    wrapInQuotes?: boolean;
+    display?: React_2.ReactNode;
+    label?: React_2.ReactNode;
+    value: string | number | boolean;
+    disabled?: boolean;
+}
+
+declare interface SelectProps {
+    options?: SelectOption[];
+    value?: string | number | boolean | Array<string | number>;
+    defaultValue?: string | number | boolean | Array<string | number>;
+    onChange?: (value: any, option?: SelectOption) => void;
+    onSelect?: (value: string | number | boolean, option: SelectOption) => void;
+    dropdownRender?: (menu: React_2.ReactNode) => React_2.ReactNode;
+    optionRender?: (option: {
+        data: SelectOption;
+    }) => React_2.ReactNode;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: 'large' | 'middle' | 'small';
+    allowClear?: boolean;
+    onClear?: () => void;
+    optionLabelProp?: string;
+    loading?: boolean;
+    showSearch?: boolean;
+    filterOption?: boolean | ((input: string, option: SelectOption) => boolean);
+    mode?: 'multiple' | 'tags';
+    variant?: string;
+    suffixIcon?: React_2.ReactNode;
+    popupMatchSelectWidth?: boolean | number;
+    tokenSeparators?: string[];
+    maxCount?: number;
+    overlayClassName?: string;
+    needConfirm?: boolean;
+    className?: string;
+    style?: React_2.CSSProperties;
+}
+
+declare type SetDecisionGraphOptions = {
+    skipOnChangeEvent?: boolean;
+};
+
+export declare type Simulation = {
+    result?: SimulationOk;
+} & {
+    error?: SimulationError;
+};
+
+export declare type SimulationError = {
+    title?: string;
+    message?: string;
+    data: {
+        nodeId?: string;
+    };
+};
+
+export declare type SimulationOk = {
+    performance: string;
+    result: Output;
+    snapshot: DecisionGraphType;
+    trace: Record<string, SimulationTrace>;
+};
+
+export declare type SimulationTrace<Trace = TraceDataVariants> = {
+    input: Input | null;
+    output: Output | null;
+    name: string;
+    id: string;
+    performance: string | null;
+    traceData: Trace | null;
+    order?: number;
+};
+
+export declare type SimulationTraceDataExpression = Arrayable<Record<string, {
+    result: unknown;
+}>>;
+
+export declare type SimulationTraceDataFunction = {
+    log?: TraceFunctionLog[];
+};
+
+export declare type SimulationTraceDataSwitch = {
+    statements: {
+        id: string;
+    }[];
+};
+
+export declare type SimulationTraceDataTable = SimulationTraceDataTableSingle | SimulationTraceDataTableSingle[];
+
+declare type SimulationTraceDataTableSingle = {
+    index: number;
+    reference_map: Record<string, unknown>;
+    rule: Record<string, string>;
+};
+
+export declare const SimulatorEditor: default_2.FC<SimulatorEditorProps>;
+
+declare type SimulatorEditorProps = {
+    value?: string;
+    onChange?: (value: string | undefined) => void;
+    readOnly?: boolean;
+};
+
+declare type SimulatorExampleBinding = {
+    nodeId: string;
+    sourceIndex: number;
+    sourceName?: string;
+} | null;
+
+declare type SimulatorRequestPanelProps = {
+    defaultRequest?: string;
+    onChange?: (contextJson: string) => void;
+    hasInputNode?: boolean;
+    loading?: boolean;
+    onRun?: (payload: {
+        graph: DecisionGraphType;
+        context: unknown;
+    }) => void;
+};
+
+export declare type Slice<T = unknown> = {
+    serialize: () => T;
+    restore: (state: T) => void;
+};
+
+declare type SpaceProps = React_2.HTMLAttributes<HTMLDivElement> & {
+    size?: number | [number, number] | 'small' | 'middle' | 'large';
+    direction?: 'horizontal' | 'vertical';
+    wrap?: boolean;
+};
+
+declare type SplitPath<Path extends string, Obj> = Path extends `${infer Prefix}.${infer Rest}` ? {
+    [K in Prefix]: SplitPath<Rest, Obj>;
+} : {
+    [K in Path]: Obj;
+};
+
+export declare const stringifyRequestSchemaValue: (schema?: unknown) => string;
+
+export declare const switchNodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<NodeKind.Switch>;
+    content: z.ZodObject<{
+        hitPolicy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            first: "first";
+            collect: "collect";
+        }>>>, z.ZodTransform<"first" | "collect", "first" | "collect" | null | undefined>>;
+        statements: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            condition: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+            isDefault: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, z.ZodTransform<boolean, boolean | null | undefined>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    position: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare interface SwitchProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    size?: 'default' | 'small';
+    className?: string;
+    style?: React_2.CSSProperties;
+    onChange?: (checked: boolean) => void;
+    checkedChildren?: React_2.ReactNode;
+    unCheckedChildren?: React_2.ReactNode;
+}
+
+declare type SwitchStatement = {
+    id: string;
+    condition?: string;
+    isDefault?: boolean;
+} & Diff;
+
+export declare type TabCustomFunctionProps = {
+    id: string;
+    user?: string;
+    customFunctions?: any;
+};
+
+declare type TableCellProps = {
+    column?: ({
+        colType: string;
+    } & TableSchemaItem) | undefined;
+    value: string;
+    diff?: DiffMetadata | undefined;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    index: number;
+};
+
+declare type TableCursor = {
+    x: string;
+    y: number;
+};
+
+export declare type TableSchemaItem = {
+    id: string;
+    name: string;
+    field?: string;
+    defaultValue?: string;
+    fieldType?: ColumnFieldType;
+    outputFieldType?: OutputFieldType;
+    _diff?: DiffMetadata;
+};
+
+export declare type TableScrollApi = {
+    getTopRowIndex: () => number;
+    scrollToRowIndex: (index: number) => void;
+};
+
+export declare const TabRequest: default_2.FC<TabRequestProps>;
+
+export declare type TabRequestProps = {
+    id: string;
+    manager?: DragDropManager;
+    menuList?: unknown[];
+    type?: string;
+};
+
+declare interface TabsItemType {
+    key: string;
+    label: React_2.ReactNode;
+    children?: React_2.ReactNode;
+    disabled?: boolean;
+}
+
+export declare type TabSnapshot = Record<string, unknown>;
+
+declare interface TabsProps {
+    items?: TabsItemType[];
+    activeKey?: string;
+    defaultActiveKey?: string;
+    onChange?: (key: string) => void;
+    type?: 'line' | 'card' | 'editable-card';
+    size?: 'large' | 'middle' | 'small';
+    className?: string;
+    rootClassName?: string;
+    style?: React_2.CSSProperties;
+    tabBarExtraContent?: React_2.ReactNode;
+}
+
+declare type TextInput = {
+    control: 'text';
+    label?: string;
+};
+
+export declare type ThemeConfig = {
+    mode?: 'light' | 'dark';
+    token?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+
+declare type ThemeSeeds = {
+    primary?: string;
+    success?: string;
+    error?: string;
+    warning?: string;
+    info?: string;
+    fieldInput?: string;
+    fieldOutput?: string;
+};
+
+export declare const ToolbarAnchor: default_2.FC<{
+    items?: ToolbarItem[];
+}>;
+
+export declare type ToolbarItem = {
+    id: string;
+    group?: string;
+    order?: number;
+    render: (ctx: {
+        disabled: boolean;
+    }) => default_2.ReactNode;
+};
+
+declare type TraceDataVariants = SimulationTraceDataTable | SimulationTraceDataFunction | SimulationTraceDataExpression | SimulationTraceDataSwitch | null;
+
+declare type TraceFunctionLog = {
+    lines: string[];
+    msSinceRun: number;
+};
+
+declare type TranslationKey = keyof typeof en;
+
+export declare const updateRequestSchemaExamples: (schemaValue: unknown, examples: Array<Record<string, unknown>>, examplesMeta?: RequestExampleMeta[]) => string;
+
+export declare function useDecisionGraphActions(): DecisionGraphStoreType['actions'];
+
+export declare function useDecisionGraphListeners<T>(selector: (state: DecisionGraphStoreType['listeners']) => T, equals?: (a: any, b: any) => boolean): T;
+
+export declare function useDecisionGraphRaw(): {
+    stateStore: ExposedStore<DecisionGraphStoreType["state"]>;
+    listenerStore: ExposedStore<DecisionGraphStoreType["listeners"]>;
+    referenceStore: ExposedStore<DecisionGraphStoreType["references"]>;
+    actions: DecisionGraphStoreType["actions"];
+};
+
+export declare function useDecisionGraphReferences<T>(selector: (state: DecisionGraphStoreType['references']) => T, equals?: (a: any, b: any) => boolean): T;
+
+export declare function useDecisionGraphState<T>(selector: (state: DecisionGraphStoreType['state']) => T, equals?: (a: any, b: any) => boolean): T;
+
+export declare const useDictionaries: () => DictionaryMap;
+
+export declare const useEdgeDiff: (id: string) => {
+    diff: {
+        status: DiffStatus;
+    } | undefined;
+};
+
+declare const useGraphClipboard: (reactFlow: RefObject<ReactFlowInstance | null>, wrapper: RefObject<HTMLDivElement | null>) => {
+    copyNodes: (nodes: Node_2[]) => Promise<void>;
+    pasteNodes: () => Promise<void>;
+};
+
+export declare function useGraphSerializer<T = unknown>(key: string | null | undefined, slice: Slice<T>, deps?: default_2.DependencyList): void;
+
+export declare const useNodeDiff: (id: string) => {
+    diff: {
+        status: DiffStatus;
+        fields?: Record<string, DiffMetadata>;
+    } | undefined;
+    contentDiff: any;
+};
+
+export declare const useNodeType: (id: string, { attachGlobals, disabled }?: NodeTypeParams) => VariableType | undefined;
+
+export declare const usePersistentState: <S>(key: string, defaultValue?: S) => [S | undefined, Dispatch<SetStateAction<S | undefined>>];
+
+declare type UserResolver = () => Promise<{
+    user?: string;
+}> | null;
+
+export declare const useSimulatorAutoSync: ({ enabled, requestValue, requestSourcesSignature, boundRequestSourceIndex, onSyncToSchema, onPushToEditor, debounceMs, }: UseSimulatorAutoSyncParams) => {
+    flush: () => void;
+};
+
+export declare type UseSimulatorAutoSyncParams = {
+    enabled: boolean;
+    requestValue: string | undefined;
+    requestSourcesSignature: string;
+    boundRequestSourceIndex: number;
+    onSyncToSchema: () => void;
+    onPushToEditor: () => void;
+    debounceMs?: number;
+};
+
+export declare const useT: () => ((key: TranslationKey | string, params?: InterpolationParams) => string);
+
+export declare function useTabSerializer<T = unknown>(tabId: string | null | undefined, key: string | null | undefined, slice: Slice<T>, deps?: default_2.DependencyList): void;
+
+export declare const useThemeMode: () => "light" | "dark";
+
+export declare const useWasmReady: () => boolean;
+
+export declare const validationSchema: z.ZodObject<{
+    inputSchema: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodAny>>>;
+    outputSchema: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodAny>>>;
+}, z.core.$strip>;
+
+declare type ViewConfig = {
+    enabled: boolean;
+    description?: string;
+    permissions?: Record<string, ViewConfigPermission | null | undefined> | null;
+};
+
+declare type ViewConfigPermission = 'edit:values' | 'edit:rules' | 'edit:full';
+
+export { }
+
+
+declare global {
+    interface Window {
+        monaco?: Monaco;
+    }
+}
+
+
+declare module '@gorules/zen-engine-wasm' {
+    interface VariableType {
+        __hash: string;
+    }
+}
+
+
+declare namespace ContextMenuSub {
+    var displayName: string;
+}
+
+declare namespace console {
+  function log(...args: any[]): void;
+  async function sleep(durationMs: number): Promise<void>;
+}
+
+
+
+declare namespace errorUtil {
+  type ErrMessage =
+    | string
+    | {
+        message?: string;
+      };
+  const errToObj: (message?: ErrMessage | undefined) => {
+    message?: string | undefined;
+  };
+  const toString: (message?: ErrMessage | undefined) => string | undefined;
+}
+
+
+
+declare namespace partialUtil {
+  type DeepPartial<T extends ZodTypeAny> =
+    T extends ZodObject<ZodRawShape>
+      ? ZodObject<
+          {
+            [k in keyof T['shape']]: ZodOptional<DeepPartial<T['shape'][k]>>;
+          },
+          T['_def']['unknownKeys'],
+          T['_def']['catchall']
+        >
+      : T extends ZodArray<infer Type, infer Card>
+        ? ZodArray<DeepPartial<Type>, Card>
+        : T extends ZodOptional<infer Type>
+          ? ZodOptional<DeepPartial<Type>>
+          : T extends ZodNullable<infer Type>
+            ? ZodNullable<DeepPartial<Type>>
+            : T extends ZodTuple<infer Items>
+              ? {
+                  [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
+                } extends infer PI
+                ? PI extends ZodTupleItems
+                  ? ZodTuple<PI>
+                  : never
+                : never
+              : T;
+}