treege 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/editor/components/input/ComboboxWithCreate.d.ts

@@ -5,7 +5,8 @@ export type ComboboxOption = {
 /**
  * Reusable Combobox component with search, create, and clear functionality
  */
-declare const ComboboxWithCreate: ({ options, value, onValueChange, placeholder, searchPlaceholder, createLabel, clearLabel, emptyLabel, className, allowClear, allowCreate, }: {
+declare const ComboboxWithCreate: ({ options, id, value, onValueChange, placeholder, searchPlaceholder, createLabel, clearLabel, emptyLabel, className, allowClear, allowCreate, }: {
+    id?: string;
     options: ComboboxOption[];
     value?: string | null;
     onValueChange?: (newValue: string) => void;

package/dist/editor/components/styles/EditorStyles.d.ts

@@ -0,0 +1,2 @@
+declare const EditorStyles: () => import("react/jsx-runtime").JSX.Element;
+export default EditorStyles;

package/dist/editor/constants/defaultNode.d.ts

@@ -1,4 +1,4 @@
-export declare const defaultNode: {
+export declare const DEFAULT_NODE: {
     data: {
         type: string;
     };

package/dist/editor/constants/edgeTypes.d.ts

@@ -1,3 +1,4 @@
-export declare const edgeTypes: {
-    conditional: ({ id, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: import('../features/TreegeEditor/edges/ConditionalEdge').ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EDGE_TYPES: {
+    conditional: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: import('../features/TreegeEditor/edges/ConditionalEdge').ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
+    default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: import('@xyflow/react').EdgeProps) => import("react/jsx-runtime").JSX.Element>;
 };

package/dist/editor/constants/inputTypeIcons.d.ts

@@ -0,0 +1,3 @@
+import { LucideIcon } from 'lucide-react';
+export declare const INPUT_TYPE_ICONS: Record<string, LucideIcon>;
+export declare const DEFAULT_INPUT_TYPE_ICON: import('react').ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & import('react').RefAttributes<SVGSVGElement>>;

package/dist/editor/constants/nodeSpacing.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Constants for node spacing and positioning in the flow editor
+ */
+/**
+ * Vertical spacing between nodes (in pixels)
+ * Used when creating nodes via handle click or AI generation
+ */
+export declare const VERTICAL_NODE_SPACING = 100;
+/**
+ * Horizontal offset when placing sibling nodes (in pixels)
+ */
+export declare const HORIZONTAL_NODE_OFFSET = 50;
+/**
+ * Horizontal spacing for AI-generated flows (in pixels)
+ */
+export declare const AI_HORIZONTAL_SPACING = 350;
+/**
+ * Position tolerance for detecting nodes at the same Y position (in pixels)
+ */
+export declare const POSITION_TOLERANCE = 20;
+/**
+ * Default direction for the auto-layout algorithm.
+ * "TB" = top to bottom, "LR" = left to right.
+ */
+export declare const LAYOUT_DIRECTION = "TB";
+/**
+ * Vertical gap between ranks (parent → child) used by the auto-layout (in pixels).
+ */
+export declare const LAYOUT_VERTICAL_SPACING = 80;
+/**
+ * Horizontal gap between siblings used by the auto-layout (in pixels).
+ */
+export declare const LAYOUT_HORIZONTAL_SPACING = 60;

package/dist/editor/constants/nodeTypes.d.ts

@@ -1,6 +1,5 @@
-export declare const nodeTypes: {
-    flow: ({ data, isConnectable, type, parentId }: import('../features/TreegeEditor/nodes/FlowNode').FlowNodeProps) => import("react/jsx-runtime").JSX.Element;
-    group: ({ data }: import('../features/TreegeEditor/nodes/GroupNode').GroupNodeProps) => import("react/jsx-runtime").JSX.Element;
-    input: ({ data, isConnectable, type, parentId }: import('../features/TreegeEditor/nodes/InputNode').InputNodeProps) => import("react/jsx-runtime").JSX.Element;
-    ui: ({ data, isConnectable, type, parentId }: import('../features/TreegeEditor/nodes/UINode').UINodeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const NODE_TYPES: {
+    group: () => null;
+    input: import('react').MemoExoticComponent<(props: import('../features/TreegeEditor/nodes/TreegeNode').TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    ui: import('react').MemoExoticComponent<(props: import('../features/TreegeEditor/nodes/TreegeNode').TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
 };

package/dist/editor/context/OpenApiContext.d.ts

@@ -0,0 +1,79 @@
+import { ReactNode } from 'react';
+import { ApiRoute, OpenApiDocument } from '../types/openapi';
+/**
+ * The exact input the user fed to the OpenAPI dialog last time it loaded
+ * successfully. Kept around so re-opening the dialog can pre-fill the field
+ * (the user may want to tweak/re-load the same source).
+ */
+export type OpenApiSourceInput = {
+    mode: "url";
+    value: string;
+} | {
+    mode: "json";
+    value: string;
+};
+interface OpenApiContextValue {
+    /**
+     * The currently loaded OpenAPI document, or `null` when none is set.
+     */
+    document: OpenApiDocument | null;
+    /**
+     * Memoized flat list of routes derived from `document`.
+     */
+    routes: ApiRoute[];
+    /**
+     * User-provided base URL that overrides the document's `servers[0].url`.
+     * Useful when the OpenAPI spec points at a different environment than the
+     * one the user wants to call (e.g. staging vs prod). Empty string means
+     * "no override — use the document's declared server".
+     */
+    baseUrlOverride: string;
+    /**
+     * Effective base URL: the override when non-empty, otherwise the document's
+     * first declared server. Trailing slash trimmed.
+     */
+    baseUrl: string;
+    /**
+     * Last source input (URL or pasted JSON) used to load the document. `null`
+     * before the user has loaded anything.
+     */
+    lastSourceInput: OpenApiSourceInput | null;
+    /**
+     * Replace the loaded document. Pass `null` to clear.
+     */
+    setDocument: (next: OpenApiDocument | null) => void;
+    /**
+     * Replace the base URL override. Pass `""` to clear.
+     */
+    setBaseUrlOverride: (next: string) => void;
+    /**
+     * Record the last source input the user used to load the document.
+     */
+    setLastSourceInput: (next: OpenApiSourceInput | null) => void;
+}
+interface OpenApiProviderProps {
+    children: ReactNode;
+    /**
+     * Initial OpenAPI source. Accepts either a pre-parsed document or a URL
+     * string — when a URL is given, the provider fetches it on mount and
+     * toasts on failure (matching the runtime behavior of the dialog).
+     */
+    initialDocument?: OpenApiDocument | string | null;
+    /**
+     * Initial base URL. When set, takes precedence over the document's
+     * `servers[0].url`. Empty string means "no override".
+     */
+    initialBaseUrl?: string;
+}
+/**
+ * Holds the current OpenAPI document at editor scope. The document is
+ * editor-local state (not persisted in the flow JSON), so reloading the
+ * editor with a different consumer-supplied initial document is supported.
+ */
+export declare const OpenApiProvider: ({ children, initialDocument, initialBaseUrl }: OpenApiProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Read the OpenAPI context. Returns a no-op default outside of the provider
+ * so consumers (e.g., URL combobox) don't have to null-check.
+ */
+export declare const useOpenApi: () => OpenApiContextValue;
+export {};

package/dist/editor/context/TreegeEditorContext.d.ts

@@ -1,11 +1,70 @@
 import { PropsWithChildren } from 'react';
+import { AIConfig } from '../types/ai';
+import { HttpHeader } from '../../shared/types/node';
 export interface TreegeEditorContextValue {
+    /**
+     * Current language
+     */
     language: string;
+    /**
+     * Current flow ID
+     */
     flowId?: string;
+    /**
+     * Global HTTP headers used by editor-time HTTP calls (e.g. the
+     * "Detect fields" button). Forwarded by the consumer; same shape and
+     * semantics as `TreegeRenderer`'s `headers`.
+     */
+    headers?: HttpHeader[];
+    /**
+     * Function to set the current flow ID
+     * @param flow
+     */
     setFlowId?: (flow?: string) => void;
+    /**
+     * AI configuration for tree generation
+     */
+    aiConfig?: AIConfig;
+    /**
+     * Whether the node actions sheet is open
+     */
+    isNodeSheetOpen: boolean;
+    /**
+     * Function to open or close the node actions sheet
+     */
+    setIsNodeSheetOpen: (open: boolean) => void;
+    /**
+     * ID of the node pending deletion confirmation, or null if no deletion is pending
+     */
+    pendingDeleteNodeId: string | null;
+    /**
+     * Open the deletion confirmation dialog for a given node
+     */
+    openDeleteNodeConfirmation: (id: string) => void;
+    /**
+     * Close the deletion confirmation dialog (cancels any pending deletion)
+     */
+    closeDeleteNodeConfirmation: () => void;
+    /**
+     * Pending node type change that requires user confirmation (when the target type only supports a single outgoing edge).
+     */
+    pendingNodeTypeChange: PendingNodeTypeChange | null;
+    /**
+     * Open the node type change confirmation dialog.
+     */
+    openNodeTypeChangeConfirmation: (payload: PendingNodeTypeChange) => void;
+    /**
+     * Close the node type change confirmation dialog (cancels the pending change).
+     */
+    closeNodeTypeChangeConfirmation: () => void;
+}
+export interface PendingNodeTypeChange {
+    nodeId: string;
+    type: string;
+    subType?: string;
 }
 export interface TreegeEditorProviderProps extends PropsWithChildren {
-    value: TreegeEditorContextValue;
+    value: Omit<TreegeEditorContextValue, "isNodeSheetOpen" | "setIsNodeSheetOpen" | "pendingDeleteNodeId" | "openDeleteNodeConfirmation" | "closeDeleteNodeConfirmation" | "pendingNodeTypeChange" | "openNodeTypeChangeConfirmation" | "closeNodeTypeChangeConfirmation">;
 }
 export declare const TreegeEditorContext: import('react').Context<TreegeEditorContextValue | null>;
 export declare const TreegeEditorProvider: ({ children, value }: TreegeEditorProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/editor/features/TreegeEditor/TreegeEditor.d.ts

@@ -1,3 +1,3 @@
 import { TreegeEditorProps } from '../../types/editor';
-declare const TreegeEditor: ({ edges, nodes, flow, onExportJson, onSave, theme, language }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
+declare const TreegeEditor: ({ flow, onExportJson, onSave, theme, language, aiConfig, extraMenuItems, openApi, openApiBaseUrl, onAuthorize, headers, onHeadersChange, }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
 export default TreegeEditor;

package/dist/editor/features/TreegeEditor/controls/MiniMapControl.d.ts

@@ -0,0 +1,6 @@
+interface MiniMapControlProps {
+    show: boolean;
+    onToggle: () => void;
+}
+declare const MiniMapControl: ({ show, onToggle }: MiniMapControlProps) => import("react/jsx-runtime").JSX.Element;
+export default MiniMapControl;

package/dist/editor/features/TreegeEditor/dialogs/AuthorizeDialog.d.ts

@@ -0,0 +1,20 @@
+import { HttpHeader } from '../../../../shared/types/node';
+interface AuthorizeDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onAuthorize?: (headers: HttpHeader[]) => void;
+}
+/**
+ * Reads supported security schemes from the loaded OpenAPI document and
+ * collects credentials from the user (Bearer token, API key value, or
+ * OAuth2 password grant). On submit, exchanges OAuth2 credentials at the
+ * token endpoint, builds the resulting `HttpHeader[]`, and calls
+ * `onAuthorize` so the consumer can forward them to the renderer's
+ * global `headers`.
+ *
+ * Inspired by Swagger UI's "Authorize" modal. OAuth2 flows other than
+ * `password` (auth_code, client_credentials, implicit) are out of scope —
+ * they require browser redirects, server-side state, or PKCE.
+ */
+declare const AuthorizeDialog: ({ open, onOpenChange, onAuthorize }: AuthorizeDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default AuthorizeDialog;

package/dist/editor/features/TreegeEditor/dialogs/ChangeNodeTypeDialog.d.ts

@@ -0,0 +1,2 @@
+declare const ChangeNodeTypeDialog: () => import("react/jsx-runtime").JSX.Element;
+export default ChangeNodeTypeDialog;

package/dist/editor/features/TreegeEditor/dialogs/DeleteNodeDialog.d.ts

@@ -0,0 +1,2 @@
+declare const DeleteNodeDialog: () => import("react/jsx-runtime").JSX.Element;
+export default DeleteNodeDialog;

package/dist/editor/features/TreegeEditor/dialogs/HeadersDialog.d.ts

@@ -0,0 +1,19 @@
+import { HttpHeader } from '../../../../shared/types/node';
+interface HeadersDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    headers: HttpHeader[];
+    onChange: (headers: HttpHeader[]) => void;
+}
+/**
+ * Edit the editor's "global headers" — forwarded to every HTTP request the
+ * runtime form issues (HTTP inputs, submit buttons, options-source fetches).
+ * Field-level headers configured on individual nodes override these on key
+ * collision (case-insensitive).
+ *
+ * The dialog is fully controlled: the parent owns the headers list and
+ * receives every mutation via `onChange`, so the same value can be forwarded
+ * to `TreegeRenderer` without any state duplication.
+ */
+declare const HeadersDialog: ({ open, onOpenChange, headers, onChange }: HeadersDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default HeadersDialog;

package/dist/editor/features/TreegeEditor/dialogs/OpenApiDialog.d.ts

@@ -0,0 +1,6 @@
+interface OpenApiDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+declare const OpenApiDialog: ({ open, onOpenChange }: OpenApiDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default OpenApiDialog;

package/dist/editor/features/TreegeEditor/edges/ConditionalEdge.d.ts

@@ -2,5 +2,5 @@ import { Edge, EdgeProps } from '@xyflow/react';
 import { ConditionalEdgeData } from '../../../../shared/types/edge';
 export type ConditionalEdgeType = Edge<ConditionalEdgeData, "conditional">;
 export type ConditionalEdgeProps = EdgeProps<ConditionalEdgeType>;
-declare const ConditionalEdge: ({ id, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element;
-export default ConditionalEdge;
+declare const _default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
+export default _default;

package/dist/editor/features/TreegeEditor/edges/DefaultEdge.d.ts

@@ -0,0 +1,3 @@
+import { EdgeProps } from '@xyflow/react';
+declare const _default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: EdgeProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/editor/features/TreegeEditor/forms/OptionsSourceForm.d.ts

@@ -0,0 +1,7 @@
+import { OptionsSource } from '../../../../shared/types/node';
+interface OptionsSourceFormProps {
+    value: OptionsSource | undefined;
+    onChange: (value: OptionsSource | undefined) => void;
+}
+declare const OptionsSourceForm: ({ value, onChange }: OptionsSourceFormProps) => import("react/jsx-runtime").JSX.Element;
+export default OptionsSourceForm;

package/dist/editor/features/TreegeEditor/forms/SubmitConfigForm.d.ts

@@ -0,0 +1,7 @@
+import { SubmitConfig } from '../../../../shared/types/node';
+interface SubmitConfigFormProps {
+    value: SubmitConfig | undefined;
+    onChange: (config: SubmitConfig | undefined) => void;
+}
+declare const SubmitConfigForm: ({ value, onChange }: SubmitConfigFormProps) => import("react/jsx-runtime").JSX.Element;
+export default SubmitConfigForm;

package/dist/editor/features/TreegeEditor/inputs/ApiUrlCombobox.d.ts

@@ -0,0 +1,30 @@
+import { ComponentProps, ReactNode } from 'react';
+import { ApiRouteMethod } from '../../../types/openapi';
+import { Input } from '../../../../shared/components/ui/input';
+interface ApiUrlComboboxProps extends Omit<ComponentProps<typeof Input>, "onChange" | "value" | "children"> {
+    value: string;
+    /**
+     * Called whenever the URL changes. When `method` is set, the user picked
+     * a route from the OpenAPI document — callers should also update their
+     * HTTP method state accordingly.
+     */
+    onChange: (url: string, method?: ApiRouteMethod) => void;
+    /**
+     * Optional trailing adornments rendered next to the input (e.g. a variable
+     * picker). Always rendered, regardless of whether an OpenAPI document is
+     * loaded.
+     */
+    children?: ReactNode;
+}
+/**
+ * URL field that augments a regular `<Input>` with a Popover suggesting
+ * routes from the editor-loaded OpenAPI document. The user can either type
+ * a custom URL freely (current behavior preserved) or click the Globe icon
+ * to pick a route — selecting one resolves the URL with the document's
+ * server and emits the route's HTTP method back to the caller.
+ *
+ * When no OpenAPI document is loaded, the Globe trigger is hidden and the
+ * component is functionally identical to a plain `<Input>`.
+ */
+declare const ApiUrlCombobox: ({ value, onChange, placeholder, children, ...inputProps }: ApiUrlComboboxProps) => import("react/jsx-runtime").JSX.Element;
+export default ApiUrlCombobox;

package/dist/editor/features/TreegeEditor/inputs/ComboboxPattern.d.ts

@@ -1,6 +1,7 @@
 interface ComboboxPatternProps {
     value?: string | null;
     onValueChange?: (newValue: string) => void;
+    id?: string;
 }
-declare const ComboboxPattern: ({ value, onValueChange }: ComboboxPatternProps) => import("react/jsx-runtime").JSX.Element;
+declare const ComboboxPattern: ({ id, value, onValueChange }: ComboboxPatternProps) => import("react/jsx-runtime").JSX.Element;
 export default ComboboxPattern;

package/dist/editor/features/TreegeEditor/inputs/OptionImageField.d.ts

@@ -0,0 +1,6 @@
+interface OptionImageFieldProps {
+    value?: string;
+    onChange: (value: string) => void;
+}
+declare const OptionImageField: ({ value, onChange }: OptionImageFieldProps) => import("react/jsx-runtime").JSX.Element;
+export default OptionImageField;

package/dist/editor/features/TreegeEditor/inputs/SelectNodeGroup.d.ts

@@ -1,2 +1,23 @@
-declare const SelectNodeGroup: () => import("react/jsx-runtime").JSX.Element | null;
+import { TreegeNode } from '../../../../shared/types/node';
+interface SelectNodeGroupProps {
+    /**
+     * Nodes to operate on. When omitted, falls back to the currently selected
+     * node from `useNodesSelection` (preserves the original Sheet behavior).
+     * Pass an array to drive the input from the multi-selection panel; all
+     * mutations (assign / create) are applied to every node in the list.
+     */
+    targetNodes?: TreegeNode[];
+    /**
+     * When true, hides the label above the Select (used by compact panels
+     * where a label would be redundant).
+     */
+    hideLabel?: boolean;
+    /**
+     * Fired after a successful group assignment or creation. Lets the parent
+     * dismiss its surrounding surface (e.g. the badge popover) on commit.
+     * Rename is intentionally excluded — it keeps the surface open.
+     */
+    onChange?: () => void;
+}
+declare const SelectNodeGroup: ({ targetNodes, hideLabel, onChange }?: SelectNodeGroupProps) => import("react/jsx-runtime").JSX.Element | null;
 export default SelectNodeGroup;

package/dist/editor/features/TreegeEditor/layout/AutoLayout.d.ts

@@ -0,0 +1,15 @@
+import { LayoutOptions } from '../../../utils/dagreLayout';
+/**
+ * Keeps the flow laid out automatically using Dagre.
+ *
+ * Runs once all nodes have been measured, then re-runs whenever any node's
+ * measured size changes. Positions computed by Dagre replace the current
+ * `position` of each node — manual repositioning is therefore overridden,
+ * which is the expected behavior for a decision-tree editor where topology
+ * drives layout.
+ *
+ * Group children are laid out independently within their parent, preserving
+ * React Flow's parent-relative coordinate system.
+ */
+declare const AutoLayout: ({ direction, horizontalSpacing, verticalSpacing }?: LayoutOptions) => null;
+export default AutoLayout;

package/dist/editor/features/TreegeEditor/nodes/TreegeNode.d.ts

@@ -0,0 +1,5 @@
+import { Node, NodeProps } from '@xyflow/react';
+import { InputNodeData, UINodeData } from '../../../../shared/types/node';
+export type TreegeNodeProps = NodeProps<Node<InputNodeData, "input">> | NodeProps<Node<UINodeData, "ui">>;
+declare const _default: import('react').MemoExoticComponent<(props: TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/editor/features/TreegeEditor/nodes/components/BottomHandleDropdown.d.ts

@@ -0,0 +1,9 @@
+interface BottomHandleDropdownProps {
+    nodeId: string;
+    isConnectable?: boolean;
+    hidden?: boolean;
+    /** Whether branching (forking into two nodes) is allowed — only for input nodes. */
+    canBranch?: boolean;
+}
+declare const BottomHandleDropdown: ({ nodeId, isConnectable, hidden, canBranch }: BottomHandleDropdownProps) => import("react/jsx-runtime").JSX.Element;
+export default BottomHandleDropdown;

package/dist/editor/features/TreegeEditor/nodes/components/NodeGroupBadge.d.ts

@@ -0,0 +1,6 @@
+interface NodeGroupBadgeProps {
+    nodeId: string;
+    groupId?: string;
+}
+declare const NodeGroupBadge: ({ nodeId, groupId }: NodeGroupBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeGroupBadge;

package/dist/editor/features/TreegeEditor/nodes/components/NodeImage.d.ts

@@ -0,0 +1,5 @@
+interface NodeImageProps {
+    image?: string;
+}
+declare const NodeImage: ({ image }: NodeImageProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeImage;

package/dist/editor/features/TreegeEditor/nodes/components/NodeImageButton.d.ts

@@ -0,0 +1,6 @@
+interface NodeImageButtonProps {
+    nodeId: string;
+    image?: string;
+}
+declare const NodeImageButton: ({ nodeId, image }: NodeImageButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeImageButton;

package/dist/editor/features/TreegeEditor/nodes/components/NodeInputPreview.d.ts

@@ -0,0 +1,12 @@
+import { InputNodeData } from '../../../../../shared/types/node';
+interface NodeInputPreviewProps {
+    nodeId: string;
+    /**
+     * Input node data. Optional so the parent can pass it unconditionally —
+     * the component returns `null` when undefined or when the runtime renderer
+     * for this input type isn't available.
+     */
+    data?: InputNodeData;
+}
+declare const NodeInputPreview: ({ nodeId, data }: NodeInputPreviewProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeInputPreview;

package/dist/editor/features/TreegeEditor/nodes/components/NodeLabelInput.d.ts

@@ -0,0 +1,10 @@
+import { Translatable } from '../../../../../shared/types/translate';
+interface NodeLabelInputProps {
+    nodeId: string;
+    label?: Translatable;
+    placeholder?: string;
+    className?: string;
+    autoFocus?: boolean;
+}
+declare const NodeLabelInput: ({ nodeId, label, placeholder, className, autoFocus }: NodeLabelInputProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeLabelInput;

package/dist/editor/features/TreegeEditor/nodes/components/NodeMoreMenu.d.ts

@@ -0,0 +1,6 @@
+interface NodeMoreMenuProps {
+    nodeId: string;
+    className?: string;
+}
+declare const NodeMoreMenu: ({ nodeId, className }: NodeMoreMenuProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeMoreMenu;

package/dist/editor/features/TreegeEditor/nodes/components/NodeRequiredButton.d.ts

@@ -0,0 +1,6 @@
+interface NodeRequiredButtonProps {
+    nodeId: string;
+    required?: boolean;
+}
+declare const NodeRequiredButton: ({ nodeId, required }: NodeRequiredButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeRequiredButton;

package/dist/editor/features/TreegeEditor/nodes/components/NodeStackOrderButtons.d.ts

@@ -0,0 +1,6 @@
+interface NodeStackOrderButtonsProps {
+    nodeId: string;
+    selected?: boolean;
+}
+declare const NodeStackOrderButtons: ({ nodeId, selected }: NodeStackOrderButtonsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeStackOrderButtons;

package/dist/editor/features/TreegeEditor/nodes/components/NodeTypeBadge.d.ts

@@ -0,0 +1,7 @@
+interface NodeTypeBadgeProps {
+    nodeId: string;
+    nodeType: string;
+    subType?: string;
+}
+declare const NodeTypeBadge: ({ nodeId, nodeType, subType }: NodeTypeBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeTypeBadge;

package/dist/editor/features/TreegeEditor/nodes/layout/NodeWrapper.d.ts

@@ -1,6 +1,8 @@
 import { PropsWithChildren } from 'react';
+import { StackPosition } from '../../../../utils/stackPositionIndex';
 interface NodeWrapperProps extends PropsWithChildren {
-    inGroup: boolean;
+    isSubmit?: boolean;
+    stackPosition?: StackPosition;
 }
-declare const NodeWrapper: ({ children, inGroup }: NodeWrapperProps) => import("react/jsx-runtime").JSX.Element;
+declare const NodeWrapper: ({ children, isSubmit, stackPosition }: NodeWrapperProps) => import("react/jsx-runtime").JSX.Element;
 export default NodeWrapper;

package/dist/editor/features/TreegeEditor/panel/AIGeneratorDialog.d.ts

@@ -0,0 +1,16 @@
+import { Edge, Node } from '@xyflow/react';
+import { AIConfig } from '../../../types/ai';
+export interface AIGeneratorDialogProps {
+    /**
+     * AI configuration from context
+     */
+    aiConfig?: AIConfig;
+    /**
+     * Callback when tree is generated
+     */
+    onGenerate: (data: {
+        edges: Edge[];
+        nodes: Node[];
+    }) => void;
+}
+export declare const AIGeneratorDialog: ({ aiConfig, onGenerate }: AIGeneratorDialogProps) => import("react/jsx-runtime").JSX.Element;

package/dist/editor/features/TreegeEditor/panel/ActionsPanel.d.ts

@@ -1,7 +1,12 @@
-import { Flow } from '../../../../shared/types/node';
+import { ExtraMenuItem } from '../../../types/editor';
+import { Flow, HttpHeader } from '../../../../shared/types/node';
 export interface ActionsPanelProps {
     onExportJson?: (data: Flow) => void;
     onSave?: (data: Flow) => void;
+    extraMenuItems?: ExtraMenuItem[];
+    onAuthorize?: (headers: HttpHeader[]) => void;
+    headers?: HttpHeader[];
+    onHeadersChange?: (headers: HttpHeader[]) => void;
 }
-declare const ActionsPanel: ({ onExportJson, onSave }: ActionsPanelProps) => import("react/jsx-runtime").JSX.Element;
+declare const ActionsPanel: ({ onExportJson, onSave, extraMenuItems, onAuthorize, headers, onHeadersChange }: ActionsPanelProps) => import("react/jsx-runtime").JSX.Element;
 export default ActionsPanel;

package/dist/editor/features/TreegeEditor/panel/MultiSelectionPanel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Floating bar that appears at the top-center of the canvas when two or more
+ * nodes are selected. Exposes batch actions: assign a group (reuses
+ * `SelectNodeGroup`), delete the selection, or clear it.
+ */
+declare const MultiSelectionPanel: () => import("react/jsx-runtime").JSX.Element | null;
+export default MultiSelectionPanel;

package/dist/editor/hooks/useAvailableParentFields.d.ts

@@ -1,7 +1,20 @@
+/**
+ * Returns every Input ancestor reachable from the given node, traversing
+ * incoming edges depth-first. Cycle-safe (visited set). The result is the
+ * pool of fields that a downstream node — typically a conditional edge —
+ * may reference: each entry exposes the ancestor's `nodeId`, resolved
+ * display `label`, raw `name`, input `type`, and static `options` (when
+ * defined), so consumers can render a Select/Input bound to the right
+ * source value.
+ *
+ * Non-Input ancestors (UI nodes, flow nodes, groups) are excluded because
+ * they cannot supply a runtime value to evaluate a condition against.
+ */
 declare const useAvailableParentFields: (currentNodeId?: string) => {
     label: string;
     name: string | undefined;
     nodeId: string;
+    options: import('../../shared/types/node').InputOption[] | undefined;
     type: import('../../shared/types/node').InputType;
 }[];
 export default useAvailableParentFields;

package/dist/editor/hooks/useFlowActions.d.ts

@@ -4,9 +4,13 @@
  */
 declare const useFlowActions: () => {
     clearSelection: () => void;
+    deleteNode: (id: string) => void;
+    deleteNodes: (ids: string[]) => void;
+    deleteSelectedNode: () => void;
+    selectNode: (id: string) => void;
     updateNodeData: <T extends Record<string, unknown>>(id: string, data: Partial<T>) => void;
-    updateNodeType: (id: string, type: string) => void;
+    updateNodeType: (id: string, type: string, subType?: string) => void;
     updateSelectedNodeData: <T extends Record<string, unknown>>(data: Partial<T>) => void;
-    updateSelectedNodeType: (type: string) => void;
+    updateSelectedNodeType: (type: string, subType?: string) => void;
 };
 export default useFlowActions;