import { WorkspaceProps } from './workflow-canvas.js';
export { Workspace } from './workflow-canvas.js';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { Workflow, WorkflowGraph, AgentModel, WorkflowTool, AgentRule, AgentPersistPayload, LogicNodeConfig, AgentOutputSchema, AgentTool, WorkflowRun } from './contracts.js';
export { AgentNodeConfig, ModelProviderNodeConfig, ModelProviderType } from './contracts.js';
import { A as AgentWithPrompts, a as AgentNodeData, T as ToolCanvasData, R as RuleNodeData, E as EntityNodeData, M as ModelProviderNodeData, S as StartNodeData, b as EndNodeData, I as IfElseNodeData, C as CodeNodeData, H as HttpRequestNodeData, c as S3WriteNodeData, d as TemplateTransformNodeData, e as IterationNodeData, K as KnowledgeBaseNodeData, f as AnswerNodeData, Q as QuestionClassifierNodeData, P as ParameterExtractorNodeData, V as VariableAssignerNodeData, g as VariableAggregatorNodeData, D as DocumentExtractorNodeData, L as ListOperatorNodeData, h as IterationStartNodeData, N as NoteNodeData, G as GroupNodeData, W as WorkflowEntityDefinition } from '../index-CoB18TbG.js';
export { i as AgentNodeTool } from '../index-CoB18TbG.js';
import * as React$1 from 'react';
import { ReactNode, ComponentProps } from 'react';
export { GraphNodeBadge, GraphNodeHeader, GraphNodeIconBubble, GraphNodeMeta } from './graph-node.js';
import { a as RuleCondition, b as RuleAction } from '../rule-form-BYJzyork.js';
export { c as ExecutionTimelineEntry, E as ExecutionTimelineLabels, d as ExecutionTimelineMetrics, e as ExecutionTimelinePanel, f as ExecutionTimelinePanelProps, g as ExecutionTimelineStatus, h as RULE_STATUS_OPTIONS, i as RuleConditionOperator, j as RuleForm, R as RuleFormValue, k as RuleStatus, T as TIMEZONE_OPTIONS, l as TimeWindow, m as defaultRuleForm } from '../rule-form-BYJzyork.js';
import { D as DynamicIslandConfirm$1 } from '../dynamic-island-confirm-BKsZkAEP.js';
import { N as NodeRunResult } from '../workflow-store-o17I6L6A.js';
export { W as WorkflowStore, u as useWorkflowStore } from '../workflow-store-o17I6L6A.js';
import * as zustand from 'zustand';
import { Node, Edge } from '@xyflow/react';
export { AgentTier, NodeValidationIssue, ValidationResult, createDefaultLogicNodeConfig, getAgentTier, topologicalSortAgents, validateGraphNodeConfigs, validateNodeConfig, validateWorkflowGraph } from './utils.js';
export { L as LayoutDirection, a as applyDagreLayout } from '../layout-engine-YZcVr20M.js';

type WorkspaceBootstrapPayload = {
    workflow: Workflow | null;
    graph: WorkflowGraph | null;
    agents: AgentWithPrompts[];
    models: AgentModel[];
    tools: WorkflowTool[];
    rules: AgentRule[];
};
type WorkflowBuilderClient = {
    publishableKey: string;
    getWorkspaceBootstrap: (workflowId: string) => Promise<WorkspaceBootstrapPayload>;
};
type WorkflowBuilderProviderProps = {
    publishableKey: string;
    children: React.ReactNode;
};
declare function WorkflowBuilderProvider({ publishableKey, children, }: WorkflowBuilderProviderProps): react_jsx_runtime.JSX.Element;
declare function useWorkflowBuilderClient(): WorkflowBuilderClient;
declare function useWorkflowBuilderClientOptional(): WorkflowBuilderClient | null;

interface NodeCardProps {
    /** React Flow selection state */
    selected?: boolean;
    /** Node type key for border colors (e.g. 'agent', 'tool', 'if_else') */
    nodeType: string;
    /** Width class — defaults to 'w-[260px]' */
    width?: string;
    /** Custom border class override (e.g. group node with dynamic colors) */
    customBorder?: string;
    /** Display variant — 'error' shows dashed amber border for missing entities */
    variant?: 'default' | 'error';
    /** Compact density mode for short-card view */
    compact?: boolean;
    /** Additional CSS classes */
    className?: string;
    /** Inline styles */
    style?: React.CSSProperties;
    /** Interactive attributes for div-based clickable nodes */
    role?: string;
    tabIndex?: number;
    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
    onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;
    onDoubleClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
    children: ReactNode;
}
/**
 * Base card container for all standard flow nodes.
 *
 * Provides shared styling: rounded corners, border, glassmorphism surface,
 * padding, selection/hover state ring, and group context for child hover effects.
 *
 * Nodes that do NOT use this: NoteFlowNode (custom bg/border), GroupFlowNode expanded (resizable container).
 */
declare function NodeCard({ selected, nodeType, width, customBorder, variant, compact, className, style, role, tabIndex, onClick, onKeyDown, onDoubleClick, children, }: NodeCardProps): react_jsx_runtime.JSX.Element;

declare const AgentFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: AgentNodeData;
    selected?: boolean;
}>;

declare const ToolFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: ToolCanvasData;
    selected?: boolean;
}>;

declare const RuleFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: RuleNodeData;
    selected?: boolean;
}>;

declare const EntityFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: EntityNodeData;
    selected?: boolean;
}>;

declare const ModelProviderFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: ModelProviderNodeData;
    selected?: boolean;
}>;

declare const StartFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: StartNodeData;
    selected?: boolean;
}>;

declare const EndFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: EndNodeData;
    selected?: boolean;
}>;

declare const IfElseFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: IfElseNodeData;
    selected?: boolean;
}>;

declare const CodeFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: CodeNodeData;
    selected?: boolean;
}>;

declare const HttpRequestFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: HttpRequestNodeData;
    selected?: boolean;
}>;

declare const S3WriteFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: S3WriteNodeData;
    selected?: boolean;
}>;

declare const TemplateTransformFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: TemplateTransformNodeData;
    selected?: boolean;
}>;

declare const IterationFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: IterationNodeData;
    selected?: boolean;
}>;

declare const KnowledgeBaseFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: KnowledgeBaseNodeData;
    selected?: boolean;
}>;

declare const AnswerFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: AnswerNodeData;
    selected?: boolean;
}>;

declare const QuestionClassifierFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: QuestionClassifierNodeData;
    selected?: boolean;
}>;

declare const ParameterExtractorFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: ParameterExtractorNodeData;
    selected?: boolean;
}>;

declare const VariableAssignerFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: VariableAssignerNodeData;
    selected?: boolean;
}>;

declare const VariableAggregatorFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: VariableAggregatorNodeData;
    selected?: boolean;
}>;

declare const DocumentExtractorFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: DocumentExtractorNodeData;
    selected?: boolean;
}>;

declare const ListOperatorFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: ListOperatorNodeData;
    selected?: boolean;
}>;

declare const IterationStartFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: IterationStartNodeData;
    selected?: boolean;
}>;

declare const NoteFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: NoteNodeData;
    selected?: boolean;
}>;

declare const GroupFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: GroupNodeData;
    selected?: boolean;
}>;

type AgentModalProps = {
    onSaved?: () => void;
    /**
     * Called when the user clicks Save in the sidebar footer. The modal
     * collects its local editable state (profile + framework + prompt +
     * advanced + tools + connection) into a canonical payload so the
     * parent can decide how to persist (POST for create, PATCH for edit).
     * Returning a rejected promise re-opens the unsaved-changes banner.
     */
    onPersist?: (payload: AgentPersistPayload) => Promise<void>;
};
declare function AgentModal({ onSaved, onPersist }: AgentModalProps): react_jsx_runtime.JSX.Element | null;

type SubworkflowModalProps = {
    /** Called when save/create is clicked — receives the merged workflow tool with updated graph */
    onSaved?: (tool: WorkflowTool) => void;
    /** Called when maximize is clicked — navigate to full workflow editor */
    onMaximize?: (subworkflowId: string) => void;
};
declare function SubworkflowModal({ onSaved, onMaximize }: SubworkflowModalProps): react_jsx_runtime.JSX.Element | null;

type DatasourceDefinition = {
    id: string;
    name: string;
    dialect: string;
};
type LogicNodeModalProps = {
    onSave: (nodeId: string, updatedConfig: LogicNodeConfig) => void;
    entities?: WorkflowEntityDefinition[];
    datasources?: DatasourceDefinition[];
    onLoadTables?: (datasourceId: string) => Promise<string[]>;
    onLoadSchema?: (datasourceId: string, table: string) => Promise<Array<{
        name: string;
        type: string;
        nullable?: boolean;
    }>>;
};
declare function LogicNodeModal({ onSave, entities, datasources, onLoadTables, onLoadSchema }: LogicNodeModalProps): react_jsx_runtime.JSX.Element | null;

type PipelineSettingsPatch = {
    name: string;
    description: string;
    slug?: string | null;
    isDraft?: boolean;
    isActive?: boolean;
};
type PipelineSettingsModalProps = {
    /** Receives only the fields that actually changed — the page wrapper
     *  can then PATCH once with exactly the delta. */
    onSave: (changes: PipelineSettingsPatch) => Promise<void>;
};
declare function PipelineSettingsModal({ onSave }: PipelineSettingsModalProps): react_jsx_runtime.JSX.Element;

type ReplayInputVariables = Record<string, unknown>;
type RunReplayModalProps = {
    open: boolean;
    onClose: () => void;
    runId: string;
    workflowId: string;
    /** The original run's `inputVariables` map. Keys become the form
     *  rows; types are inferred (string/number/boolean/json) so the
     *  inputs render appropriately. */
    originalInputs: ReplayInputVariables;
    /** Receives the override map. Empty object → verbatim re-run. */
    onReplay: (overrides: ReplayInputVariables) => Promise<void>;
};
declare function RunReplayModal({ open, onClose, runId, workflowId, originalInputs, onReplay, }: RunReplayModalProps): react_jsx_runtime.JSX.Element;

type OutputSchemaBuilderProps = {
    /** Stored schema. `undefined` renders the "no schema yet" state with
     *  a single button to create one. */
    value?: AgentOutputSchema;
    onChange: (next: AgentOutputSchema | undefined) => void;
    /** Recursion depth — used to cap the nesting UI offers (deeper trees
     *  are still expressible by hand-editing JSON, but the visual builder
     *  tops out at 2 to keep the page readable). */
    depth?: number;
};
declare function OutputSchemaBuilder({ value, onChange, depth }: OutputSchemaBuilderProps): react_jsx_runtime.JSX.Element;
declare function defaultAgentOutputSchema(): AgentOutputSchema;

type Props$1 = {
    value: RuleCondition;
    onChange: (next: RuleCondition) => void;
    /** Recursion depth. Boolean_expression is capped at one level to keep
     *  the UI legible — deeper trees remain round-trippable via the raw
     *  JSON fallback but the visual builder won't surface sub-boolean
     *  operands. */
    depth?: number;
};
declare function RuleConditionBuilder({ value, onChange, depth }: Props$1): react_jsx_runtime.JSX.Element;
declare function defaultRuleCondition(): RuleCondition;

type Props = {
    value: RuleAction;
    onChange: (next: RuleAction) => void;
};
/**
 * Action builder — emits a single `{ type, params }` object matching the
 * executor contract. The `custom` type drops to a raw key/value editor for
 * actions the UI doesn't have a dedicated template for.
 */
declare function RuleActionBuilder({ value, onChange }: Props): react_jsx_runtime.JSX.Element;
declare function defaultRuleAction(): RuleAction;

type ModelProvider = {
    id: string;
    name: string;
    provider: string;
    modelCount: number;
    configured: boolean;
};
type NodePaletteProps = {
    agents: AgentWithPrompts[];
    tools: WorkflowTool[];
    agentTools?: AgentTool[];
    rules: AgentRule[];
    entities?: WorkflowEntityDefinition[];
    modelProviders?: ModelProvider[];
    onCreateAgent?: () => void;
    onCreateTool?: () => void;
    onCreateAgentTool?: () => void;
    onCreateRule?: () => void;
    onCreateDatasource?: () => void;
    onConfigureProvider?: (providerId: string) => void;
};
declare function NodePalette({ agents, tools, agentTools, rules, entities, modelProviders, onCreateAgent, onCreateTool, onCreateAgentTool, onCreateRule, onCreateDatasource, onConfigureProvider }: NodePaletteProps): react_jsx_runtime.JSX.Element;

type WorkflowListBarProps = {
    workflows: Workflow[];
    activeWorkflowId: string | null;
    isLoading: boolean;
    onSelect: (workflow: Workflow) => void;
    onCreate: () => void;
    onDelete: (workflowId: string, workflowName: string) => void;
    onConvertToSubworkflow?: (workflow: Workflow) => void;
};
declare function WorkflowListBar({ workflows, activeWorkflowId, isLoading, onSelect, onCreate, onDelete, onConvertToSubworkflow, }: WorkflowListBarProps): react_jsx_runtime.JSX.Element;

type WorkflowVersion = {
    version: number;
    publishedAt: string;
    publishedBy: string;
    nodeCount: number;
    edgeCount: number;
};
type VersionHistoryPanelProps = {
    open: boolean;
    onClose: () => void;
    workflowId: string;
    currentVersion: number;
    onPreview: (version: WorkflowVersion) => void;
    onRestore: (version: WorkflowVersion) => void;
    fetchVersions?: (workflowId: string) => Promise<WorkflowVersion[]>;
};
declare function VersionHistoryPanel({ open, onClose, workflowId, currentVersion, onPreview, onRestore, fetchVersions, }: VersionHistoryPanelProps): react_jsx_runtime.JSX.Element | null;

type RunPanelProps = {
    open: boolean;
    onClose: () => void;
    onRun: () => void;
    onStop: () => void;
};
declare function RunPanel({ open, onClose, onRun, onStop }: RunPanelProps): react_jsx_runtime.JSX.Element | null;

type VariableInspectorProps = {
    open: boolean;
    onClose: () => void;
};
declare function VariableInspector({ open, onClose }: VariableInspectorProps): react_jsx_runtime.JSX.Element | null;

type VariableValue = string | number | boolean | null;
type RunInputDialogProps = {
    open: boolean;
    onClose: () => void;
    onRun: (inputVariables: Record<string, VariableValue>) => void;
};
declare function RunInputDialog({ open, onClose, onRun, }: RunInputDialogProps): react_jsx_runtime.JSX.Element | null;

type PreviewPanelProps = {
    open: boolean;
    onClose: () => void;
    workflowId: string;
    loadRuns: (workflowId: string) => Promise<WorkflowRun[]>;
};
declare function PreviewPanel({ open, onClose, workflowId, loadRuns }: PreviewPanelProps): react_jsx_runtime.JSX.Element | null;

type SaveStatusBadgeProps = {
    status: 'idle' | 'saving' | 'saved';
};
declare function SaveStatusBadge({ status }: SaveStatusBadgeProps): react_jsx_runtime.JSX.Element | null;

type AutoSaveWorkspaceProps = Omit<WorkspaceProps, 'onGraphChange'> & {
    onAutoSaveGraph: (graph: WorkflowGraph) => void;
    onGraphSnapshot?: (graph: WorkflowGraph) => void;
};
declare const AutoSaveWorkspace: React$1.NamedExoticComponent<AutoSaveWorkspaceProps>;

type NodeContextMenuProps = {
    position: {
        x: number;
        y: number;
    };
    targetId: string;
    onClose: () => void;
    onEdit: (nodeId: string) => void;
    onDuplicate: (nodeId: string) => void;
    onCopy: (nodeId: string) => void;
    onDelete: (nodeId: string) => void;
};
declare function NodeContextMenu({ position, targetId, onClose, onEdit, onDuplicate, onCopy, onDelete }: NodeContextMenuProps): react_jsx_runtime.JSX.Element;

type AlignDirection = 'left' | 'right' | 'top' | 'bottom' | 'centerHorizontal' | 'centerVertical';
type DistributeDirection = 'horizontal' | 'vertical';
type SelectionContextMenuProps = {
    position: {
        x: number;
        y: number;
    };
    onClose: () => void;
    onCopy: () => void;
    onDuplicate: () => void;
    onDelete: () => void;
    onGroupSelected: () => void;
    onAlign: (direction: AlignDirection) => void;
    onDistribute: (direction: DistributeDirection) => void;
};

declare function SelectionContextMenu({ position, onClose, onCopy, onDuplicate, onDelete, onGroupSelected, onAlign, onDistribute, }: SelectionContextMenuProps): react_jsx_runtime.JSX.Element;

type PanelContextMenuProps = {
    position: {
        x: number;
        y: number;
    };
    onClose: () => void;
    onPaste: () => void;
    onSelectAll: () => void;
    onFitView: () => void;
    onAddNote: (flowPosition: {
        x: number;
        y: number;
    }) => void;
    flowPosition: {
        x: number;
        y: number;
    };
    hasClipboardContent: boolean;
};
declare function PanelContextMenu({ position, onClose, onPaste, onSelectAll, onFitView, onAddNote, flowPosition, hasClipboardContent }: PanelContextMenuProps): react_jsx_runtime.JSX.Element;

type DynamicIslandConfirmProps = ComponentProps<typeof DynamicIslandConfirm$1>;
declare function DynamicIslandConfirm(props: DynamicIslandConfirmProps): react_jsx_runtime.JSX.Element;

type DslExportModalProps = {
    open: boolean;
    onClose: () => void;
    workflow: Workflow;
    graph: WorkflowGraph;
};
declare function DslExportModal({ open, onClose, workflow, graph }: DslExportModalProps): react_jsx_runtime.JSX.Element | null;

type DslImportModalProps = {
    open: boolean;
    onClose: () => void;
    onImport: (graph: WorkflowGraph) => void;
};
declare function DslImportModal({ open, onClose, onImport }: DslImportModalProps): react_jsx_runtime.JSX.Element | null;

type SubworkflowStoreState = {
    /** The workflow tool being edited (null = modal closed) */
    tool: WorkflowTool | null;
    /** Whether the modal is open */
    open: boolean;
    /** Editable fields */
    name: string;
    category: string;
    description: string;
    timeoutMs: number;
    retryCount: number;
    /** Whether there are unsaved changes */
    dirty: boolean;
};
type SubworkflowStoreActions = {
    /** Open the modal with a workflow tool (empty toolId = create mode) */
    openModal: (tool: WorkflowTool) => void;
    /** Close the modal and reset state */
    closeModal: () => void;
    /** Update a field and mark dirty */
    setName: (name: string) => void;
    setCategory: (category: string) => void;
    setDescription: (description: string) => void;
    setTimeoutMs: (timeoutMs: number) => void;
    setRetryCount: (retryCount: number) => void;
    /** Mark as dirty (e.g. when graph changes) */
    markDirty: () => void;
    /** Mark as saved */
    markSaved: () => void;
};
type SubworkflowStore = SubworkflowStoreState & SubworkflowStoreActions;
declare const useSubworkflowStore: zustand.UseBoundStore<zustand.StoreApi<SubworkflowStore>>;

type ModalType = 'agent' | 'logic-node' | 'pipeline-settings' | null;
type AgentModalData = {
    agent: AgentWithPrompts;
    models: AgentModel[];
    /** Available agent tools the agent can use */
    agentTools?: AgentTool[];
    /** Available model providers for credential config */
    modelProviders?: ModelProvider[];
    isCreateMode: boolean;
};
type LogicNodeModalData = {
    nodeId: string;
    nodeLabel: string;
    config: LogicNodeConfig;
};
type PipelineSettingsModalData = {
    name: string;
    description: string;
    /** Optional — populated when opening the modal against an already-
     *  loaded workflow so admins can archive / flip draft state without
     *  closing the modal. Callers that don't care about lifecycle (e.g.
     *  create-from-dialog flows) can leave these out. */
    slug?: string | null;
    isDraft?: boolean;
    isActive?: boolean;
};
type ModalEntry = {
    type: ModalType;
    agentData: AgentModalData | null;
    logicNodeData: LogicNodeModalData | null;
    pipelineSettingsData: PipelineSettingsModalData | null;
};
type ModalStoreState = {
    /** Current active modal (top of stack) */
    activeModal: ModalType;
    agentData: AgentModalData | null;
    logicNodeData: LogicNodeModalData | null;
    pipelineSettingsData: PipelineSettingsModalData | null;
    /** Stack of previous modals (for back-navigation) */
    stack: ModalEntry[];
};
type ModalStoreActions = {
    openAgentModal: (agent: AgentWithPrompts, models: AgentModel[], isCreateMode?: boolean, agentTools?: AgentTool[], modelProviders?: ModelProvider[]) => void;
    openLogicNodeModal: (nodeId: string, nodeLabel: string, config: LogicNodeConfig) => void;
    openPipelineSettingsModal: (name: string, description: string, lifecycle?: {
        slug?: string | null;
        isDraft?: boolean;
        isActive?: boolean;
    }) => void;
    /** Close current modal. If stack has entries, restores the previous modal. */
    closeModal: () => void;
    /** Close all modals and clear the stack. */
    closeAllModals: () => void;
};
type ModalStore = ModalStoreState & ModalStoreActions;
declare const useModalStore: zustand.UseBoundStore<zustand.StoreApi<ModalStore>>;

/**
 * Workflow Store Selectors
 * ========================
 * Derived state hooks for granular subscriptions.
 * Each selector subscribes only to the slice it needs,
 * preventing unnecessary re-renders in consuming components.
 */
declare const useCanUndo: () => boolean;
declare const useCanRedo: () => boolean;
declare const useHasCopied: () => boolean;
declare const useContextMenu: () => {
    type: "node" | "edge" | "panel";
    position: {
        x: number;
        y: number;
    };
    targetId?: string;
} | null;
declare const useEditingNodeId: () => string | null;
declare const useSelectedNodeCount: () => number;
declare const useIsRunning: () => boolean;
declare const useNodeResults: () => Record<string, NodeRunResult>;

type UseUndoRedoReturn = {
    undo: () => void;
    redo: () => void;
    canUndo: boolean;
    canRedo: boolean;
    takeSnapshot: () => void;
};
declare function useUndoRedo(nodes: Node[], edges: Edge[], setNodes: (nodes: Node[]) => void, setEdges: (edges: Edge[]) => void, maxHistory?: number): UseUndoRedoReturn;

type UseClipboardReturn = {
    copy: () => void;
    paste: () => void;
    hasCopied: boolean;
};
declare function useClipboard(nodes: Node[], edges: Edge[], setNodes: (updater: (nodes: Node[]) => Node[]) => void, setEdges: (updater: (edges: Edge[]) => Edge[]) => void, takeSnapshot: () => void): UseClipboardReturn;

type UseCanvasShortcutsOptions = {
    undo: () => void;
    redo: () => void;
    copy: () => void;
    paste: () => void;
    canUndo: boolean;
    canRedo: boolean;
    selectAll: () => void;
    fitView: () => void;
};
declare function useCanvasShortcuts({ undo, redo, copy, paste, canUndo, canRedo, selectAll, fitView, }: UseCanvasShortcutsOptions): void;

/**
 * Help Lines Hook
 * ===============
 * Detects alignment between the currently dragged node and
 * all other nodes on the canvas. When edges (left, center, right,
 * top, center-y, bottom) are within a 5px threshold, returns
 * horizontal and/or vertical guide line positions for visual feedback.
 */

type NodeDragHandler = (event: React.MouseEvent, node: Node, nodes: Node[]) => void;
type HelpLinePosition = {
    horizontal: number | null;
    vertical: number | null;
};
/**
 * Basic help lines hook. Returns a drag handler factory that accepts
 * the full node list for alignment detection.
 *
 * Example:
 *   const { helpLines, createDragHandler, onNodeDragStop } = useHelpLines()
 *   const onNodeDrag = createDragHandler(nodes)
 */
declare function useHelpLines(): {
    helpLines: HelpLinePosition;
    createDragHandler: (allNodes: Node[]) => NodeDragHandler;
    onNodeDragStop: NodeDragHandler;
};

/**
 * Agent framework icons — LangChain, CrewAI, Google ADK, Anthropic Claude Agent SDK.
 * SVG paths sourced from simple-icons where available.
 */
type AgentFramework = 'langchain' | 'crewai' | 'google-adk' | 'anthropic' | 'strands' | 'openai' | 'custom';
type FrameworkIconProps = {
    className?: string;
};
declare function LangChainIcon({ className }: FrameworkIconProps): react_jsx_runtime.JSX.Element;
declare function CrewAIIcon({ className }: FrameworkIconProps): react_jsx_runtime.JSX.Element;
declare function AnthropicIcon({ className }: FrameworkIconProps): react_jsx_runtime.JSX.Element;
declare function GoogleADKIcon({ className }: FrameworkIconProps): react_jsx_runtime.JSX.Element;
declare function StrandsIcon({ className }: FrameworkIconProps): react_jsx_runtime.JSX.Element;
declare function OpenAIIcon({ className }: FrameworkIconProps): react_jsx_runtime.JSX.Element;
/** Color + label metadata for each framework */
declare const FRAMEWORK_META: Record<AgentFramework, {
    label: string;
    color: string;
    badgeColor: string;
    IconComponent: (props: FrameworkIconProps) => React.ReactNode;
}>;
/** Get the framework icon + metadata for a given framework key */
declare function getFrameworkMeta(framework: string | undefined): {
    label: string;
    color: string;
    badgeColor: string;
    IconComponent: (props: FrameworkIconProps) => React.ReactNode;
};
/** Check if a model ID is compatible with a framework */
declare function isModelCompatibleWithFramework(modelId: string, framework: AgentFramework): boolean;
/** Filter models to only those compatible with a framework */
declare function getCompatibleModels<T extends {
    id: string;
}>(models: T[], framework: AgentFramework): T[];
/** Get the first compatible framework for a given model, or 'custom' as fallback */
declare function getDefaultFrameworkForModel(modelId: string): AgentFramework;

type AgentToolNodeData = {
    agentTool: AgentTool;
    order?: number;
    displayMode?: 'detailed' | 'compact';
    onEdit?: (agentTool: AgentTool) => void;
    onToggle?: (agentTool: AgentTool) => void;
    onRemoveFromCanvas?: (nodeId: string) => void;
    label?: string;
};
declare const AgentToolFlowNode: React$1.NamedExoticComponent<{
    id: string;
    data: AgentToolNodeData;
    selected?: boolean;
}>;

/**
 * Model provider icons for AWS Bedrock models.
 * Anthropic (Claude), Amazon (Nova), Meta (Llama).
 */
type IconProps = {
    className?: string;
};
declare function AnthropicModelIcon({ className }: IconProps): react_jsx_runtime.JSX.Element;
declare function AmazonNovaIcon({ className }: IconProps): react_jsx_runtime.JSX.Element;
declare function MetaLlamaIcon({ className }: IconProps): react_jsx_runtime.JSX.Element;
/** Returns the icon component and color for a model ID */
declare function getModelIcon(modelId: string): {
    IconComponent: (props: IconProps) => React.ReactNode;
    color: string;
    providerLabel: string;
};

declare const LOGIC_NODE_GRADIENTS: Record<string, string>;
declare const LOGIC_NODE_BADGE_COLORS: Record<string, string>;
declare const LOGIC_ICON_MAP: Record<string, React.ComponentType<{
    className?: string;
}>>;
declare const MINIMAP_NODE_COLORS: Record<string, string>;
declare const NODE_EXECUTION_ACCENT_COLORS: Record<string, string>;
declare function getNodeExecutionAccent(nodeType?: string): string;
declare function getNodeExecutionAccentRgb(nodeType?: string): string;
declare const LOGIC_NODE_HANDLE_COLORS: Record<string, string>;

/**
 * Entity Visual Helpers
 * =====================
 * Generic appearance helpers for entity nodes independent of hardcoded entity types.
 */
declare function getEntityIcon(entityKey: string | undefined): React.ComponentType<{
    className?: string;
}>;
declare function getEntityGradient(entityKey: string | undefined): string;
declare function getEntityBadgeColor(entityKey: string | undefined): string;
declare function getEntityHandleColor(entityKey: string | undefined): string;
declare function getEntityMinimapColor(entityKey: string | undefined): string;

export { AgentFlowNode, type AgentFramework, AgentModal, AgentNodeData, AgentOutputSchema, AgentToolFlowNode, AgentWithPrompts, AmazonNovaIcon, AnswerFlowNode, AnswerNodeData, AnthropicIcon, AnthropicModelIcon, AutoSaveWorkspace, type AutoSaveWorkspaceProps, CodeFlowNode, CodeNodeData, CrewAIIcon, DocumentExtractorFlowNode, DocumentExtractorNodeData, DslExportModal, DslImportModal, DynamicIslandConfirm, type DynamicIslandConfirmProps, EndFlowNode, EndNodeData, EntityFlowNode, EntityNodeData, FRAMEWORK_META, GoogleADKIcon, GroupFlowNode, GroupNodeData, HttpRequestFlowNode, HttpRequestNodeData, IfElseFlowNode, IfElseNodeData, IterationFlowNode, IterationNodeData, IterationStartFlowNode, IterationStartNodeData, KnowledgeBaseFlowNode, KnowledgeBaseNodeData, LOGIC_ICON_MAP, LOGIC_NODE_BADGE_COLORS, LOGIC_NODE_GRADIENTS, LOGIC_NODE_HANDLE_COLORS, LangChainIcon, ListOperatorFlowNode, ListOperatorNodeData, LogicNodeModal, MINIMAP_NODE_COLORS, MetaLlamaIcon, type ModelProvider, ModelProviderFlowNode, ModelProviderNodeData, NODE_EXECUTION_ACCENT_COLORS, NodeCard, NodeContextMenu, NodePalette, NodeRunResult, NoteFlowNode, NoteNodeData, OpenAIIcon, OutputSchemaBuilder, type OutputSchemaBuilderProps, PanelContextMenu, ParameterExtractorFlowNode, ParameterExtractorNodeData, PipelineSettingsModal, type PipelineSettingsPatch, PreviewPanel, type PreviewPanelProps, QuestionClassifierFlowNode, QuestionClassifierNodeData, type ReplayInputVariables, RuleAction, RuleActionBuilder, RuleCondition, RuleConditionBuilder, RuleFlowNode, RuleNodeData, RunInputDialog, type RunInputDialogProps, RunPanel, RunReplayModal, type RunReplayModalProps, S3WriteFlowNode, S3WriteNodeData, SaveStatusBadge, type SaveStatusBadgeProps, SelectionContextMenu, StartFlowNode, StartNodeData, StrandsIcon, SubworkflowModal, TemplateTransformFlowNode, TemplateTransformNodeData, ToolCanvasData, ToolFlowNode, VariableAggregatorFlowNode, VariableAggregatorNodeData, VariableAssignerFlowNode, VariableAssignerNodeData, VariableInspector, VersionHistoryPanel, type WorkflowBuilderClient, WorkflowBuilderProvider, type WorkflowBuilderProviderProps, WorkflowEntityDefinition, WorkflowGraph, WorkflowListBar, type WorkspaceBootstrapPayload, WorkspaceProps, defaultAgentOutputSchema, defaultRuleAction, defaultRuleCondition, getCompatibleModels, getDefaultFrameworkForModel, getEntityBadgeColor, getEntityGradient, getEntityHandleColor, getEntityIcon, getEntityMinimapColor, getFrameworkMeta, getModelIcon, getNodeExecutionAccent, getNodeExecutionAccentRgb, isModelCompatibleWithFramework, useCanRedo, useCanUndo, useCanvasShortcuts, useClipboard, useContextMenu, useEditingNodeId, useHasCopied, useHelpLines, useIsRunning, useModalStore, useNodeResults, useSelectedNodeCount, useSubworkflowStore, useUndoRedo, useWorkflowBuilderClient, useWorkflowBuilderClientOptional };
