treege 3.0.0-beta.9 → 3.0.0-beta.91

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/components/NodeTypePickerMenuContent.d.ts

@@ -0,0 +1,12 @@
+import { NodeInit } from '../../../../hooks/useFlowConnections';
+interface NodeTypePickerMenuContentProps {
+    /** Called with the picked node type. */
+    onSelect: (nodeInit: NodeInit) => void;
+}
+/**
+ * Shared dropdown body listing every creatable node type (inputs + UI). Used by
+ * the bottom handle (add child / branch) and the junction insert button so the
+ * picker stays identical across affordances.
+ */
+declare const NodeTypePickerMenuContent: ({ onSelect }: NodeTypePickerMenuContentProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeTypePickerMenuContent;

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, HttpHeaders } from '../../../../shared/types/node';
 export interface ActionsPanelProps {
     onExportJson?: (data: Flow) => void;
     onSave?: (data: Flow) => void;
+    extraMenuItems?: ExtraMenuItem[];
+    onAuthorize?: (headers: HttpHeaders) => void;
+    headers?: HttpHeaders;
+    onHeadersChange?: (headers: HttpHeaders) => 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;

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

@@ -1,4 +1,13 @@
 import { OnConnect, OnConnectEnd, OnEdgesDelete } from '@xyflow/react';
+/**
+ * Shape passed to the node-creating actions (`onAddFromHandle`, `onInsertAfter`,
+ * and the internal `createNodeAndConnect`). Lets callers seed the new node's
+ * `type` and `data` while React Flow handles position, id, etc.
+ */
+export type NodeInit = {
+    type: string;
+    data?: Record<string, unknown>;
+};
 /**
  * Custom hook to manage flow connections, including connecting nodes,
  * handling connection ends, and deleting edges with conditional logic.
@@ -8,8 +17,13 @@ declare const useFlowConnections: () => {
         source: string;
         target: string;
     }) => boolean;
+    moveStackNodeDown: (nodeId: string) => void;
+    moveStackNodeUp: (nodeId: string) => void;
+    onAddFromHandle: (sourceNodeId: string, nodeInit?: NodeInit) => void;
     onConnect: OnConnect;
     onConnectEnd: OnConnectEnd;
+    onCreateBranch: (sourceNodeId: string, nodeInit?: NodeInit) => void;
     onEdgesDelete: OnEdgesDelete;
+    onInsertAfter: (sourceNodeId: string, nodeInit?: NodeInit) => void;
 };
 export default useFlowConnections;

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

@@ -0,0 +1,16 @@
+/**
+ * Content flags for the current flow, used to gate editor actions.
+ *
+ * A lone `group` node is just a container — it carries no form value, so it
+ * must not make the flow "saveable". `hasInputNodes` therefore counts only
+ * `input` nodes: that is what Save and Export JSON should gate on.
+ *
+ * `isEmpty` is broader (no nodes and no edges at all) and is meant for the
+ * Clear action, which should stay enabled as long as there is anything on the
+ * canvas to wipe — including an orphan group.
+ */
+export declare const useFlowContent: () => {
+    hasInputNodes: boolean;
+    isEmpty: boolean;
+};
+export default useFlowContent;

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

@@ -0,0 +1,26 @@
+import { Edge, Node } from '@xyflow/react';
+type Snapshot = {
+    nodes: Node[];
+    edges: Edge[];
+};
+type HistoryStore = {
+    past: Snapshot[];
+    future: Snapshot[];
+    pushPast: (snapshot: Snapshot) => void;
+    popPast: () => Snapshot | undefined;
+    pushFuture: (snapshot: Snapshot) => void;
+    popFuture: () => Snapshot | undefined;
+    clearFuture: () => void;
+    reset: () => void;
+};
+/**
+ * Zustand store backing the editor's undo/redo history.
+ *
+ * Holds two stacks of `{ nodes, edges }` snapshots: `past` (states to undo into) and
+ * `future` (states to redo into). Both are capped at `MAX_HISTORY` to bound memory.
+ *
+ * Consumed exclusively by `useUndoRedo` — components should not read or mutate this
+ * store directly. Call `reset()` when loading a new flow to drop stale history.
+ */
+declare const useHistoryStore: import('zustand').UseBoundStore<import('zustand').StoreApi<HistoryStore>>;
+export default useHistoryStore;

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

@@ -0,0 +1,8 @@
+/**
+ * An edge is "stacked" when it connects two nodes that belong to the same
+ * visual chain — i.e. the source has a linear child (position "first" or
+ * "middle") and the target has a linear parent (position "middle" or "last").
+ * Stacked edges are not rendered: their endpoints touch border-to-border in
+ * the layout, making the line redundant.
+ */
+export declare const useIsStackedEdge: (source: string, target: string) => boolean;

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

@@ -0,0 +1,15 @@
+import { KeyValueEntry } from '../../shared/utils/httpRecord';
+/**
+ * Bridges an editable list of key/value rows with a persisted
+ * `Record<string, string>` (headers, query params…).
+ *
+ * Records can't hold a half-typed row (an empty key, or two rows mid-edit), so
+ * the rows are the local source of truth while editing. Every mutation is
+ * serialized back to a record — empty keys dropped, last wins on duplicates —
+ * and pushed up via `onChange`. The rows reseed from `record` only when it
+ * changes from the outside (a different node, a static↔api toggle), never in
+ * response to our own emit, so adding a blank row doesn't immediately vanish.
+ * The reseed happens during render (React's recommended pattern) rather than in
+ * an effect, so there's no extra commit/flash.
+ */
+export declare const useKeyValueRows: (record: Record<string, string> | undefined, onChange: (record: Record<string, string>) => void) => readonly [KeyValueEntry[], (rows: KeyValueEntry[]) => void];

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

@@ -10,10 +10,10 @@ declare const useNodesSelection: <TNodeData extends TreegeNodeData = TreegeNodeD
     nodes: TreegeNode[];
     selectedNode: ({
         id: string;
-        position: import('@xyflow/react').XYPosition;
+        position: import('@xyflow/system').XYPosition;
         data: TreegeNodeData;
-        sourcePosition?: import('@xyflow/react').Position;
-        targetPosition?: import('@xyflow/react').Position;
+        sourcePosition?: import('@xyflow/system').Position;
+        targetPosition?: import('@xyflow/system').Position;
         hidden?: boolean;
         selected?: boolean;
         dragging?: boolean;
@@ -28,10 +28,10 @@ declare const useNodesSelection: <TNodeData extends TreegeNodeData = TreegeNodeD
         initialHeight?: number;
         parentId?: string;
         zIndex?: number;
-        extent?: "parent" | import('@xyflow/react').CoordinateExtent | null;
+        extent?: "parent" | import('@xyflow/system').CoordinateExtent | null;
         expandParent?: boolean;
         ariaLabel?: string;
-        origin?: import('@xyflow/react').NodeOrigin;
+        origin?: import('@xyflow/system').NodeOrigin;
         handles?: import('@xyflow/system').NodeHandle[];
         measured?: {
             width?: number;

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

@@ -0,0 +1,14 @@
+import { StackPosition } from '../utils/stackPositionIndex';
+export type StackPositionInfo = {
+    position: StackPosition;
+    isStackHead: boolean;
+    isStackTail: boolean;
+    isStackMiddle: boolean;
+    isStackSingle: boolean;
+};
+/**
+ * Returns the stack position of `nodeId` plus convenience booleans derived from
+ * it. Uses a shallow equality selector so consumers only re-render when one of
+ * the booleans actually flips, not on every edge mutation.
+ */
+export declare const useStackPosition: (nodeId: string) => StackPositionInfo;

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

@@ -1,7 +1,7 @@
 /**
  * Hook for translating text in the editor with context-aware language preference.
  *
- * This hook uses the language from TreegeEditorContext and delegates to the shared useTranslate hook.
+ * This hook uses the language from TreegeEditorRuntimeContext and delegates to the shared useTranslate hook.
  *
  * @returns A function that translates either a translation key or a Translatable object
  *

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

@@ -0,0 +1,31 @@
+import { OnBeforeDelete } from '@xyflow/react';
+type UseUndoRedoOptions = {
+    enableShortcuts?: boolean;
+};
+/**
+ * Snapshot-based undo/redo for the ReactFlow editor.
+ *
+ * Maintains `past` / `future` stacks of `{ nodes, edges }` snapshots in `useHistoryStore`.
+ * Callers must invoke `takeSnapshot()` before any mutation they want to be undoable
+ * (drag start, node/edge creation, deletion, type change, …); the hook itself does
+ * not observe ReactFlow state changes.
+ *
+ * @param enableShortcuts - When true, binds Cmd/Ctrl+Z (undo) and Cmd/Ctrl+Shift+Z /
+ *   Cmd/Ctrl+Y (redo) to the window. Should be enabled in a single root component
+ *   (e.g. the editor) to avoid duplicate listeners.
+ *
+ * @returns
+ * - `takeSnapshot`: pushes the current flow onto `past` and clears `future`.
+ * - `onBeforeDelete`: adapter typed for ReactFlow's `onBeforeDelete` prop.
+ * - `undo` / `redo`: restore the previous / next snapshot.
+ * - `canUndo` / `canRedo`: booleans driven by stack length, suitable for disabling UI buttons.
+ */
+declare const useUndoRedo: ({ enableShortcuts }?: UseUndoRedoOptions) => {
+    canRedo: boolean;
+    canUndo: boolean;
+    onBeforeDelete: OnBeforeDelete;
+    redo: () => void;
+    takeSnapshot: () => void;
+    undo: () => void;
+};
+export default useUndoRedo;

package/dist/editor/types/ai.d.ts

@@ -0,0 +1,65 @@
+import { Edge, Node } from '@xyflow/react';
+/**
+ * AI Provider types for tree generation
+ */
+export type AIProvider = "gemini" | "openai" | "deepseek" | "claude";
+/**
+ * AI Configuration for tree generation
+ */
+export interface AIConfig {
+    /**
+     * The AI provider to use
+     * @default "gemini"
+     */
+    provider?: AIProvider;
+    /**
+     * API key for the selected provider
+     */
+    apiKey: string;
+    /**
+     * Optional model name override
+     * - Gemini: "gemini-2.5-flash" (default), "gemini-2.5-pro-preview-03-25"
+     * - OpenAI: "gpt-4o-mini" (default), "gpt-4o", "gpt-3.5-turbo"
+     * - DeepSeek: "deepseek-chat" (default)
+     * - Claude: "claude-3-5-haiku-20241022" (default), "claude-3-5-sonnet-20241022"
+     */
+    model?: string;
+    /**
+     * Temperature for generation (0-1, default: 0.7)
+     */
+    temperature?: number;
+}
+/**
+ * AI Generation request
+ */
+export interface AIGenerationRequest {
+    /**
+     * User prompt describing the desired tree/form
+     */
+    prompt: string;
+    /**
+     * AI configuration
+     */
+    config: AIConfig;
+}
+/**
+ * AI Generation response
+ */
+export interface AIGenerationResponse {
+    /**
+     * Generated nodes
+     */
+    nodes: Node[];
+    /**
+     * Generated edges
+     */
+    edges: Edge[];
+    /**
+     * Optional explanation or metadata
+     */
+    metadata?: {
+        explanation?: string;
+        nodesCount?: number;
+        edgesCount?: number;
+    };
+}

package/dist/editor/types/editor.d.ts

@@ -1,19 +1,32 @@
 import { Edge, Node } from '@xyflow/react';
-import { Flow } from '../../shared/types/node';
-export interface TreegeEditorProps {
+import { ReactNode } from 'react';
+import { AIConfig } from './ai';
+import { OpenApiDocument } from './openapi';
+import { Flow, HttpHeaders } from '../../shared/types/node';
+export interface ExtraMenuItem {
     /**
-     * Default flow structure containing combined nodes and edges.
-     * Note: Individual defaultNodes/defaultEdges props take precedence over this.
+     * Label displayed in the menu item.
      */
-    flow?: Flow | null;
+    label: ReactNode;
     /**
-     * Default nodes to initialize the nodes in the flow.
+     * Optional icon rendered before the label.
      */
-    nodes?: Node[];
+    icon?: ReactNode;
+    /**
+     * Callback triggered when the menu item is clicked.
+     */
+    onClick?: () => void;
+    /**
+     * When true, styles the item as destructive.
+     */
+    destructive?: boolean;
+}
+export interface TreegeEditorProps {
     /**
-     * Default edges to initialize the edges in the flow.
+     * Default flow structure containing combined nodes and edges.
+     * Note: Individual defaultNodes/defaultEdges props take precedence over this.
      */
-    edges?: Edge[];
+    flow?: Flow | null;
     /**
      * Callback function triggered when exporting JSON data.
      */
@@ -26,12 +39,95 @@ export interface TreegeEditorProps {
      * @param data
      */
     onSave?: (data: Flow) => void;
+    /**
+     * Called (debounced) whenever the canvas changes, with the current flow
+     * (id + nodes + edges). Use it for live preview or autosave. Unlike `onSave`
+     * it is not gated on having input nodes, so it also reports an emptied canvas
+     * after Clear. Unlike `onSave`/`onExportJson` it does NOT strip sensitive
+     * headers — live consumers (e.g. `TreegeRenderer`) need the real flow, so do
+     * not persist its output verbatim if that matters to you.
+     */
+    onChange?: (data: Flow) => void;
     /**
      * Theme for the editor interface.
      */
     theme?: "dark" | "light";
     /**
-     * Language for the editor interface.
+     * Controlled editor UI language. When provided, the editor runs in controlled
+     * mode: this value always wins and the built-in switcher only fires
+     * `onLanguageChange` — you must update this prop to actually change the
+     * language. Leave undefined to let the editor manage it itself (see
+     * `defaultLanguage`).
      */
     language?: string;
+    /**
+     * Initial editor UI language in uncontrolled mode. The editor seeds its
+     * internal state with this value, then owns it so the user can switch at
+     * runtime via the actions panel. Ignored when `language` is provided.
+     * @default "en"
+     */
+    defaultLanguage?: string;
+    /**
+     * Called whenever the user switches the editor language via the built-in
+     * switcher, with the newly selected language. Required to react to the change
+     * in controlled mode; optional in uncontrolled mode (use it to persist or
+     * sync the choice).
+     */
+    onLanguageChange?: (language: string) => void;
+    /**
+     * AI configuration for tree generation
+     */
+    aiConfig?: AIConfig;
+    /**
+     * Additional CSS class names for custom styling.
+     */
+    className?: string;
+    /**
+     * Extra menu items to append to the "more" dropdown of the actions panel.
+     */
+    extraMenuItems?: ExtraMenuItem[];
+    /**
+     * OpenAPI 3.x source used to power URL/route suggestions inside HTTP and
+     * Options-source forms, and to drive the Authorize flow. Accepts either:
+     * - a pre-parsed `OpenApiDocument` object
+     * - a URL string (the editor fetches it on mount and toasts on failure)
+     *
+     * Users can still load one at runtime via the editor's "OpenAPI" button.
+     */
+    openApi?: OpenApiDocument | string;
+    /**
+     * Base URL the produced tree is meant to run against. Pass the same value you
+     * give to `TreegeRenderer`'s `baseUrl`. It drives two things in the editor:
+     * - HTTP/Options-source urls are stored **relative** to it (route picker emits
+     *   relative paths), so the exported JSON stays environment-agnostic.
+     * - it is shown as a read-only prefix on URL fields and used to resolve the
+     *   "Detect fields" probe, so editor-time previews hit a real host.
+     *
+     * Works with or without OpenAPI. When an OpenAPI document is loaded, its
+     * `servers[0].url` (or the Authorize dialog override) takes precedence for
+     * route resolution; otherwise this value is the base.
+     */
+    baseUrl?: string;
+    /**
+     * Global HTTP headers applied to in-editor requests (e.g. the "Detect
+     * fields" button in `OptionsSourceForm`). Pass the same value you give to
+     * `TreegeRenderer` so editor-time previews use the same auth and headers
+     * that the runtime form will use.
+     */
+    headers?: HttpHeaders;
+    /**
+     * Called when the user submits the Authorize dialog. Receives the resulting
+     * HTTP headers (`Authorization`, API key headers…). The consumer is expected
+     * to forward those headers to `TreegeRenderer` (or `TreegeRendererProvider`)
+     * via its `headers` prop so every request issued by the form is authenticated.
+     */
+    onAuthorize?: (headers: HttpHeaders) => void;
+    /**
+     * Called whenever the user edits the global headers via the editor's
+     * built-in "Global headers" dialog. The component is controlled — the
+     * parent is expected to update its `headers` state in response and pass
+     * the new list back via the `headers` prop, so every editor-time and
+     * runtime request reflects the change.
+     */
+    onHeadersChange?: (headers: HttpHeaders) => void;
 }

package/dist/editor/types/openapi.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Minimal OpenAPI 3.x types — only what the editor needs to suggest API
+ * routes and authenticate against an API. Not a full OpenAPI definition.
+ *
+ * Swagger 2.0 (`swagger: "2.0"`) is intentionally not supported.
+ */
+export interface OpenApiDocument {
+    openapi: string;
+    info?: {
+        title?: string;
+        version?: string;
+        description?: string;
+    };
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    paths: Record<string, OpenApiPathItem | undefined>;
+    components?: {
+        securitySchemes?: Record<string, OpenApiSecurityScheme | undefined>;
+        schemas?: Record<string, OpenApiSchema>;
+    };
+}
+/**
+ * Minimal JSON Schema subset — only what's needed to generate a request-body
+ * skeleton for a route. Supports `$ref` (to `#/components/schemas/*`), objects,
+ * arrays, primitives, and `example`/`default`/`enum` hints.
+ */
+export interface OpenApiSchema {
+    $ref?: string;
+    type?: "object" | "array" | "string" | "number" | "integer" | "boolean" | "null";
+    format?: string;
+    properties?: Record<string, OpenApiSchema>;
+    items?: OpenApiSchema;
+    required?: string[];
+    enum?: unknown[];
+    example?: unknown;
+    default?: unknown;
+}
+export interface OpenApiMediaType {
+    schema?: OpenApiSchema;
+}
+export interface OpenApiRequestBody {
+    required?: boolean;
+    content?: Record<string, OpenApiMediaType>;
+}
+export interface OpenApiPathItem {
+    get?: OpenApiOperation;
+    put?: OpenApiOperation;
+    post?: OpenApiOperation;
+    delete?: OpenApiOperation;
+    patch?: OpenApiOperation;
+}
+export interface OpenApiOperation {
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    operationId?: string;
+    requestBody?: OpenApiRequestBody;
+}
+/** HTTP Bearer auth scheme. */
+export interface OpenApiHttpBearerScheme {
+    type: "http";
+    scheme: "bearer";
+    bearerFormat?: string;
+    description?: string;
+}
+/** Header-based API key auth scheme. */
+export interface OpenApiApiKeyHeaderScheme {
+    type: "apiKey";
+    in: "header";
+    name: string;
+    description?: string;
+}
+/**
+ * OAuth2 with the `password` grant. The user provides username + password
+ * directly, the editor exchanges them at `tokenUrl` and uses the returned
+ * access token as a Bearer header.
+ *
+ * Other OAuth2 flows (`authorization_code`, `client_credentials`, `implicit`)
+ * are out of scope — they require browser redirects, server-side state, or
+ * PKCE.
+ */
+export interface OpenApiOAuth2PasswordScheme {
+    type: "oauth2";
+    /** Resolved against `servers[0].url` when the spec uses a relative path. */
+    tokenUrl: string;
+    description?: string;
+}
+/**
+ * Security schemes the editor supports today. Other schemes (OAuth2 flows
+ * other than password, cookie/query API keys, openIdConnect) are filtered
+ * out at extraction time.
+ */
+export type OpenApiSecurityScheme = OpenApiHttpBearerScheme | OpenApiApiKeyHeaderScheme | OpenApiOAuth2PasswordScheme;
+export type ApiRouteMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+/**
+ * One operation extracted from an OpenAPI document, flattened to a single
+ * (method, path) record for easy listing.
+ */
+export interface ApiRoute {
+    method: ApiRouteMethod;
+    path: string;
+    summary?: string;
+    operationId?: string;
+}

package/dist/editor/utils/aiFlowGenerator.d.ts

@@ -0,0 +1,5 @@
+import { AIGenerationRequest, AIGenerationResponse } from '../types/ai';
+/**
+ * Main function to generate flow using AI
+ */
+export declare function generateFlowWithAI(request: AIGenerationRequest): Promise<AIGenerationResponse>;