import { AndCondition } from '@jsonforms/core';
import { BaseEdgeProps } from '@xyflow/react';
import { ComponentProps } from 'react';
import { ComponentType } from 'react';
import { Connection } from '@xyflow/react';
import { ControlElement as ControlElement_2 } from '@jsonforms/core';
import { default as default_2 } from 'react';
import { Edge } from '@xyflow/react';
import { EdgeProps } from '@xyflow/react';
import { EdgeTypes } from '@xyflow/react';
import { ErrorObject } from 'ajv';
import { FooterVariant } from '@synergycodes/overflow-ui';
import { HandleType } from '@xyflow/react';
import { InputProps } from '@synergycodes/overflow-ui';
import { ItemSize } from '@synergycodes/overflow-ui';
import { JsonFormsCellRendererRegistryEntry } from '@jsonforms/core';
import * as JsonFormsCore from '@jsonforms/core';
import * as JsonFormsReact from '@jsonforms/react';
import { JsonFormsRendererRegistryEntry } from '@jsonforms/core';
import { JSX } from 'react/jsx-runtime';
import { KeyCode } from '@xyflow/react';
import { LabelElement as LabelElement_2 } from '@jsonforms/core';
import { Layout as Layout_2 } from '@jsonforms/core';
import { LeafCondition } from '@jsonforms/core';
import { MemoExoticComponent } from 'react';
import { Modal } from '@synergycodes/overflow-ui';
import { MouseEvent as MouseEvent_2 } from 'react';
import { Node as Node_2 } from '@xyflow/react';
import { NodeChange } from '@xyflow/react';
import { OnConnect } from '@xyflow/react';
import { OnEdgesChange } from '@xyflow/react';
import { OnNodeDrag } from '@xyflow/react';
import { OnNodesChange } from '@xyflow/react';
import { OnSelectionChangeParams } from '@xyflow/react';
import { OrCondition } from '@jsonforms/core';
import { PropsWithChildren } from 'react';
import { ReactElement } from 'react';
import { ReactFlowInstance } from '@xyflow/react';
import { ReactFlowJsonObject } from '@xyflow/react';
import { ReactFlowProps } from '@xyflow/react';
import { RuleEffect as RuleEffect_2 } from '@jsonforms/core';
import { SchemaBasedCondition } from '@jsonforms/core';
import { StoreApi } from 'zustand';
import { TextAreaProps } from '@synergycodes/overflow-ui';
import { TranslationKey } from './features/i18n/i18next';
import { UseBoundStore } from 'zustand';
import { UseBoundStoreWithEqualityFn } from 'zustand/traditional';

declare type AccordionLayoutElement = Override<BaseLayoutElement, {
    label: string;
    type: 'Accordion';
}>;

/**
 * Subscribe to node changes (drag, resize, select, remove). The listener
 * receives xyflow's raw `NodeChange[]` for every emitted change — useful
 * for analytics, autosave, change-tracking plugins, etc.
 *
 * The registry is module-global and persists across `<WorkflowBuilder.Root>`
 * remounts — the SDK does not clear it automatically. **Plugins must call
 * {@link removeNodeChangedListener} themselves in their cleanup** (e.g.
 * `useEffect` teardown) to avoid stacking zombie listeners across mount
 * cycles. See `apps/demo/src/app/plugins/avoid-nodes-edges/providers/avoid-nodes-edges-provider.tsx`
 * for the canonical pattern.
 *
 * @returns Nothing. Call {@link removeNodeChangedListener} with the same
 *   reference to unsubscribe.
 *
 * @category Listeners
 */
export declare function addNodeChangedListener(listener: NodeChangedListener): void;

/**
 * Subscribe to "node drag started" events. The listener receives xyflow's
 * `OnNodeDrag` callback shape `(event, draggedNode, allNodes)` — fires
 * once at the start of every drag interaction, not on subsequent drag
 * frames.
 *
 * Useful for plugins that need to capture pre-drag state for snapping,
 * visual previews, or undo entries.
 *
 * The registry is module-global and persists across `<WorkflowBuilder.Root>`
 * remounts — the SDK does not clear it automatically. **Plugins must call
 * {@link removeNodeDragStartListener} themselves in their cleanup** (e.g.
 * `useEffect` teardown) to avoid stacking zombie listeners across mount
 * cycles.
 *
 * @category Listeners
 */
export declare function addNodeDragStartListener(listener: OnNodeDrag): void;

declare type AiToolsControlElement = Override<BaseControlElement, {
    type: 'AiTools';
}>;

/**
 * Combines testers — matches when all match.
 * @category Forms
 */
export declare const and: (...testers: JsonFormsCore.Tester[]) => JsonFormsCore.Tester;

declare type ArrayFieldSchema = BaseFieldSchema & {
    type: 'array';
    items: {
        type: 'object';
        properties: Record<string, FieldSchema>;
    };
};

/** Compiles only when `A extends B`. Fails the build if an owned key stops being a real ReactFlow prop (`Omit` doesn't validate keys). */
declare type AssertAssignable<A extends B, B> = A;

declare type BaseControlElement = Override<ControlElement_2, {
    rule?: UISchemaRule;
    disabled?: boolean;
}>;

declare type BaseFieldSchema = {
    label?: string;
    placeholder?: string;
};

declare type BaseLayoutElement = Override<Layout_2, {
    rule?: UISchemaRule;
    elements: UISchemaElement[];
}>;

declare type BaseNodeProperties = {
    label?: string;
    description?: string;
    errors?: FlatError[] | undefined;
    customErrors?: ErrorObject[] | undefined;
};

declare type BaseNodePropertiesSchema = {
    label: {
        type: 'string';
    };
    description: {
        type: 'string';
    };
};

declare type BooleanFieldSchema = BaseFieldSchema & {
    type: 'boolean';
};

export declare type CallbackAfter = (params: {
    params: unknown[];
    returnValue: unknown;
}) => void | {
    replacedReturn: unknown;
};

declare type CallbackBefore = (params: {
    params: unknown[];
}) => void | {
    replacedParams: unknown[];
};

/**
 * Props injected into a custom cell renderer.
 * @category Forms
 */
export declare type CellProps = JsonFormsCore.CellProps;

declare type ChangesTrackerStore = {
    lastChangeName: string;
    lastChangeParams: object;
    lastChangeTimestamp: number;
};

export declare type ComparisonOperator = (typeof comparisonsOperators)[number];

/**
 * String literal union of comparison operators recognised by the
 * dynamic-conditions / decision-branches controls (`'isEqual'`,
 * `'isGreaterThan'`, `'isContaining'`, …).
 *
 * @category Forms
 */
declare const comparisonsOperators: readonly ["isEqual", "isNotEqual", "isGreaterThan", "isLessThan", "isLessThanOrEqual", "isGreaterThanOrEqual", "isContaining", "isNotContaining", "isBefore", "isAfter"];

/**
 * Options accepted by {@link registerComponentDecorator}. Two shapes:
 *
 * - With `content`: mount a React component into a named slot — `'before'`,
 *   `'after'`, or as a `'wrapper'` around the host component.
 * - Without `content`: only `modifyProps` runs, transforming props passed to
 *   the host component without rendering extra UI.
 *
 * `priority` controls the relative order when multiple plugins decorate the
 * same slot (higher runs first; default `0`). `name` is used to deduplicate
 * registrations — passing the same `name` twice replaces the earlier entry.
 *
 * @category Plugins
 */
export declare type ComponentDecoratorOptions<Props = object> = DecoratorWithContent<Props> | DecoratorWithNoContent<Props>;

declare type ConditionalSchema = {
    properties: Record<string, FieldValidationSchema>;
};

declare type ConnectionBeingDragged = {
    handleId: string;
    nodeId: string;
};

/**
 * A uischema control element.
 * @category Forms
 */
export declare type ControlElement = JsonFormsCore.ControlElement;

/**
 * Props injected into a custom control renderer.
 * @category Forms
 */
export declare type ControlProps = JsonFormsCore.ControlProps;

declare type Convert<T> = T extends PrimitiveFieldType ? TypeMap[T] : unknown;

declare type DateFieldSchema = BaseFieldSchema & {
    type: 'string';
};

declare type DatePickerControlElement = Override<BaseControlElement, {
    type: 'DatePicker';
}>;

declare type DecisionBranchesControlElement = Override<BaseControlElement, {
    type: 'DecisionBranches';
}>;

declare type DecoratorOptionsAfter = {
    place: 'after';
    callback: CallbackAfter;
} & SharedDecoratorOptions_2;

declare type DecoratorOptionsBefore = {
    place?: 'before';
    callback: CallbackBefore;
} & SharedDecoratorOptions_2;

declare type DecoratorWithContent<Props = object> = {
    place?: 'before' | 'after' | 'wrapper';
    content: default_2.ElementType;
} & SharedDecoratorOptions<Props>;

declare type DecoratorWithNoContent<Props = object> = SharedDecoratorOptions<Props>;

/**
 * Recursive `Partial<T>`: every nested object property becomes optional
 * all the way down. Use it when a value is built up incrementally and
 * intermediate states are never fully populated.
 *
 * @category Utilities
 */
export declare type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;

/**
 * Erases the per-schema `P` parameter from a typed node template so it can
 * be stored in a {@link NodeTemplatesMap} without consumer-side casts.
 *
 * The cast is safe in practice: SDK only mounts a template for a node
 * whose palette schema produces `P`. The pair (palette item, template)
 * carries the runtime guarantee; TypeScript cannot express that link, so
 * we erase the parameter here in one well-documented spot.
 *
 * @example
 * ```ts
 * type MultiPortProperties = NodeDataProperties<typeof multiPortSchema>;
 *
 * export const MultiPortNodeTemplate = defineNodeTemplate<MultiPortProperties>(
 *   memo(({ data }: WorkflowNodeTemplateProps<MultiPortProperties>) => {
 *     const status = data?.properties.status ?? 'active';
 *     return <NodePanel.Root>…</NodePanel.Root>;
 *   }),
 * );
 * ```
 *
 * @category Components
 */
export declare function defineNodeTemplate<P>(template: ComponentType<WorkflowNodeTemplateProps<P>>): ComponentType<WorkflowNodeTemplateProps>;

/**
 * Props accepted by {@link DiagramContainer}. Use this when typing a
 * `registerComponentDecorator<DiagramContainerProps>('DiagramContainer', …)`
 * call.
 *
 * @category Components
 */
export declare type DiagramContainerProps = {
    /**
     * Extra edge types forwarded to ReactFlow alongside the built-in `'labelEdge'`
     * and any Root-level `edgeTemplates`. Merged last, so a key here intentionally
     * overrides those (this is the direct-mount escape hatch, hence no collision
     * warning); prefer `<WorkflowBuilder.Root edgeTemplates>` for app-wide edges.
     */
    edgeTypes?: EdgeTypes;
};

declare type DiagramDataModificationState = {
    onNodesChange: OnNodesChange<WorkflowBuilderNode>;
    onEdgesChange: OnEdgesChange<WorkflowBuilderEdge>;
    setNodeProperties: (nodeId: string, properties: NodeData['properties']) => void;
    setNodeData: <T extends WorkflowBuilderNode['data']>(nodeId: string, data: T) => void;
    setEdgeData: (edgeId: string, data: EdgeData) => void;
    removeElements: (elements: {
        nodes?: WorkflowBuilderNode[];
        edges?: WorkflowBuilderEdge[];
    }) => void;
};

/**
 * Persistable shape of a complete diagram: name, layout direction, and
 * xyflow's serialised viewport + nodes + edges JSON. The format used by
 * built-in templates and the integration layer.
 *
 * @category Types
 */
export declare type DiagramModel = {
    name: string;
    layoutDirection: LayoutDirection;
    diagram: ReactFlowJsonObject<WorkflowBuilderNode, WorkflowBuilderEdge>;
};

declare type DiagramSelectionState = {
    hoveredElement: string | null;
    selectedNodesIds: string[];
    selectedEdgesIds: string[];
    onEdgeMouseEnter: (_event: MouseEvent_2, edge: WorkflowBuilderEdge) => void;
    onEdgeMouseLeave: (_event: MouseEvent_2, edge: WorkflowBuilderEdge) => void;
    onSelectionChange: (event: WorkflowBuilderOnSelectionChangeParams) => void;
};

declare type DiagramState = {
    nodes: WorkflowBuilderNode[];
    edges: WorkflowBuilderEdge[];
    reactFlowInstance: WorkflowBuilderReactFlowInstance | null;
    documentName: string | null;
    globalVariables: VariablesIndex;
    isReadOnlyMode: boolean;
    layoutDirection: LayoutDirection;
    onConnect: OnConnect;
    onInit: (instance: WorkflowBuilderReactFlowInstance) => void;
    setDocumentName: (name: string) => void;
    setDiagramModel: (model?: DiagramModel, options?: {
        skipIfNotEmpty?: boolean;
    }) => void;
    setToggleReadOnlyMode: (value?: boolean) => void;
    setLayoutDirection: (value: LayoutDirection) => void;
    setConnectionBeingDragged: (nodeId: string | null, handleId: string | null) => void;
    connectionBeingDragged: ConnectionBeingDragged | null;
    draggedSegmentDestinationId: string | null;
    setDraggedSegmentDestinationId: (id: string | null) => void;
    getNodes: () => Node_2[];
};

/**
 * Resolution of a save attempt — three documented values: `'success'`
 * (committed), `'error'` (failed), `'alreadyStarted'` (a save was
 * already in flight and the new request was coalesced).
 *
 * Today's runtime treats every non-empty resolution as "the save
 * finished" and surfaces the success-style snackbar — so all three
 * variants currently look identical at the UI layer. Throw from the
 * save callback (rather than resolving to `'error'`) if you need an
 * error snackbar specifically.
 *
 * @category Integration
 */
export declare type DidSaveStatus = 'error' | 'success' | 'alreadyStarted';

declare type DraggingItem = {
    type: string;
};

/**
 * One row in a dynamic-conditions control — two operands (`x`, `y`), a
 * comparison ({@link ComparisonOperator}), and a logical operator that
 * joins this condition with the next (`'AND'` / `'OR'`).
 *
 * Operand strings can be literal values or `{{path}}` template
 * placeholders that resolve against upstream node outputs.
 *
 * @category Forms
 */
export declare type DynamicCondition = {
    x: string;
    comparisonOperator: ComparisonOperator;
    y: string;
    logicalOperator: LogicalOperator;
};

declare type DynamicConditionsControlElement = Override<BaseControlElement, {
    type: 'DynamicConditions';
}>;

/**
 * Corner radius (px) used at every bend of a smooth-step edge.
 *
 * @category Constants
 */
export declare const EDGE_CURVE_RADIUS = 16;

/**
 * Pixel gap between an edge endpoint and the connected node's bounding
 * box. Tunes the smooth-step routing used by {@link LabelEdge}.
 *
 * @category Constants
 */
export declare const EDGE_OFFSET = 20;

declare type EdgeData = {
    label?: string;
    icon?: IconType;
};

/**
 * Renders a label (text or icon) at fixed canvas coordinates, used by edge
 * components to attach descriptive content along their path. Built on top
 * of xyflow's `<EdgeLabelRenderer>` and styled via overflow-ui's
 * `<EdgeLabel>` primitive so hover / selected states match the rest of
 * the editor.
 *
 * @category Components
 */
export declare function EdgeLabel({ id, labelX, labelY, content, hovered, selected, onMouseEnter, onMouseLeave, centeringTransform, }: EdgeLabelProps): JSX.Element;

declare type EdgeLabelProps = {
    id: string;
    labelX: number;
    labelY: number;
    content: React.ReactNode;
    hovered: boolean;
    selected?: boolean;
    icon?: string;
    onMouseEnter: () => void;
    onMouseLeave: () => void;
    centeringTransform?: string;
};

/**
 * Drop-in replacement for xyflow's `<BaseEdge>` that paints a transparent
 * thicker stroke underneath the visible path. The transparent overlay
 * widens the edge's hover / click target without altering its visual
 * appearance — useful for thin edges that would otherwise be hard to grab.
 *
 * Use it inside a custom edge component the same way you'd use `BaseEdge`.
 *
 * @category Components
 */
export declare function EnhancedBaseEdge({ id, path, ...rest }: EnhancedBaseEdgeProps): JSX.Element;

declare type EnhancedBaseEdgeProps = BaseEdgeProps;

/**
 * Opt-in schema fragment exposing the runner's `errorPolicy` as a
 * Select. Spread alongside {@link sharedProperties} on node types that
 * should surface the choice in the properties panel; omit it elsewhere —
 * the runner defaults to `'fail'` when the field is absent.
 *
 * @category Utilities
 */
export declare const errorPolicyProperty: {
    readonly errorPolicy: {
        readonly type: "string";
        readonly options: {
            label: string;
            value: "fail" | "continue" | "errorRoute";
        }[];
    };
};

declare type ExtractProperties<T> = T extends {
    properties: infer P;
} ? {
    [K in keyof P]: ExtractProperties<P[K]>;
} : T extends {
    type: 'array';
    items: infer I;
} ? ExtractProperties<I>[] : T extends {
    type: infer X;
} ? Convert<X> : unknown;

declare type FieldSchema = PrimitiveFieldSchema | ArrayFieldSchema | ObjectFieldSchema | DateFieldSchema;

declare type FieldValidationSchema = ObjectFieldValidationSchema | StringFieldValidationSchema | NumberFieldValidationSchema;

declare type FlatError = {
    keyword: string;
    instancePath: string;
    schemaPath: string;
    schema?: string[];
    message?: string;
};

/**
 * Tester matching by the bound schema's `format`.
 * @category Forms
 */
export declare const formatIs: (expectedFormat: string) => JsonFormsCore.Tester;

/**
 * Wraps an arbitrary form control (input, select, etc.) with a positioned
 * `<Label>` and an optional `*` indicator for required fields. Used inside
 * custom JsonForms renderers and properties-bar tabs to keep label + control
 * spacing consistent with the rest of the editor's form UI.
 *
 * @category Components
 */
export declare function FormControlWithLabel({ label, className, required, size, children, }: PropsWithChildren<Props>): JSX.Element;

/**
 * Options accepted by {@link registerFunctionDecorator}.
 *
 * `place: 'before'` callbacks run before the wrapped function and may replace
 * its arguments. `place: 'after'` callbacks run after the wrapped function
 * and may replace its return value. `priority` controls relative order when
 * multiple plugins decorate the same function (higher runs first; default
 * `0`); `name` deduplicates registrations.
 *
 * @category Plugins
 */
export declare type FunctionDecoratorOptions = DecoratorOptionsBefore | DecoratorOptionsAfter;

/**
 * Reusable "General Information" UISchema accordion (Title / Status /
 * Description) that every standard node type can plug into its own
 * properties UI without redeclaring the three fields by hand.
 *
 * @category Utilities
 */
export declare const generalInformation: UISchema;

/**
 * Build a stable, parseable ID for a node handle. Returns the bare
 * `handleType` for outer handles and `<handleType>:inner:<innerId>` for
 * sub-handles inside compound nodes (e.g. one per decision branch or AI
 * tool). The ID is local to the owning node — xyflow scopes handle IDs by
 * node, so the same string can appear on multiple nodes without clashing.
 *
 * Use this when authoring a custom node template — pass the returned
 * string to xyflow's `<Handle id={...}>` so the editor's edge logic
 * (validation, hover, selection) can find the right handle later.
 *
 * @category Utilities
 */
export declare function getHandleId({ handleType, innerId }: GetHandleIdOptions): HandleId;

declare type GetHandleIdOptions = {
    handleType: HandleType;
    innerId?: string;
    /**
     * @deprecated Handle IDs are scoped to the owning node by xyflow, so
     * `nodeId` is no longer part of the returned string. Accepted to keep
     * 2.0.0 call sites compiling and ignored at runtime. Will be removed in
     * the next major (3.0).
     */
    nodeId?: string;
};

/**
 * Build a JsonForms `scope` pointer from a typed dot-path. Equivalent to
 * the JsonPointer fragment-encoding rule: turns `'properties.label'` into
 * `'#/properties/label'`. Generic over the schema type so TypeScript
 * autocompletes valid paths.
 *
 * @example
 * ```ts
 * getScope<typeof mySchema>('properties.label');
 * // => '#/properties/label'
 * ```
 *
 * @see https://jsonforms.io/docs/uischema/controls/#scope-string
 *
 * @category Forms
 */
export declare function getScope<T extends object>(path: PropertyPath<T> | ''): string;

/**
 * Snapshot the diagram in the shape expected by the integration layer
 * (`{ name, nodes, edges, layoutDirection }`). Use this to hand a
 * persistable payload to the host — e.g. inside a `props`-strategy
 * `onDataSave` callback or before posting to a custom backend.
 *
 * Dynamic, runtime-only values (selection, computed avoid-edge points,
 * …) are stripped by default; pass `shouldSkipDynamicValues: false` if
 * you specifically need the live values.
 *
 * @category Store
 */
export declare function getStoreDataForIntegration(params?: GetStoreDataParams): IntegrationDataFormat;

declare type GetStoreDataParams = {
    shouldSkipDynamicValues?: boolean;
};

/**
 * One-shot read of the current edges from the store (outside React).
 *
 * @category Store
 */
export declare function getStoreEdges(): WorkflowBuilderEdge[];

/**
 * Read the current diagram layout direction (`'RIGHT'` or `'DOWN'`).
 *
 * @category Store
 */
export declare function getStoreLayoutDirection(): "DOWN" | "RIGHT";

/**
 * One-shot read of the current nodes from the store (outside React).
 * Inside a component prefer `useStore((s) => s.nodes)` so the component
 * re-renders when nodes change.
 *
 * @category Store
 */
export declare function getStoreNodes(): WorkflowBuilderNode[];

/**
 * Snapshot of the currently-selected nodes + edges, in xyflow's
 * `OnSelectionChangeParams` shape. Useful from outside React when you
 * need to act on selection — e.g. on toolbar-button click to reach for
 * the selected items.
 *
 * @category Store
 */
export declare function getStoreSelection(): OnSelectionChangeParams;

/**
 * UISchema fragments rendered on every node's properties tab regardless
 * of the node type. Today contains the missing-previous-variable error
 * message; compose it into a node's UISchema with spread/merge.
 *
 * @category Utilities
 */
export declare const globalControls: UISchemaElement[];

declare type GroupLayoutElement = Override<BaseLayoutElement, {
    label: string;
    type: 'Group';
}>;

declare type HandleId = InnerHandleId | OuterHandleId;

/**
 * Test whether a plugin with the given `pluginName` is currently registered
 * for the named slot. Useful in plugin code that conditionally registers
 * dependent decorators.
 *
 * @category Plugins
 */
export declare function hasRegisteredComponentDecorator(componentName: string, pluginName: string): boolean | undefined;

declare type HorizontalLayoutElement = Override<BaseLayoutElement, {
    type: 'HorizontalLayout';
} & {
    /**
     * Defines the `grid-auto-columns` CSS property.
     * Can be any valid CSS value for the `grid-auto-columns` property:
     * - Length (e.g., '100px 1fr')
     * - Percentage (e.g., '50%')
     * - 'auto'
     */
    layoutColumns?: string;
}>;

/**
 * Lazy loads an icon from the @phosphor-icons/core package with help of SVGR loader.
 * Can be easily extended to support other .svg sources.
 */
export declare function Icon({ name, size, color, ...properties }: IconProps): JSX.Element;

declare type IconProps = {
    name: WBIcon;
    size?: Size;
    color?: string;
} & React.SVGProps<SVGSVGElement>;

/**
 * Icon name accepted by node definitions and palette items. Alias for
 * {@link WBIcon} from `@workflow-builder/icons`.
 *
 * @category Types
 */
export declare type IconType = WBIcon;

/**
 * Conditional validation block in a {@link NodeSchema} — when `if`
 * matches, `then` rules apply; otherwise `else` rules apply. Mirrors the
 * JSON-schema [if/then/else](https://json-schema.org/understanding-json-schema/reference/conditionals)
 * shape, narrowed to the field-validation subset the SDK uses.
 *
 * @category Types
 */
export declare type IfThenElseSchema = {
    if: SchemaCondition;
    then?: ConditionalSchema;
    else?: ConditionalSchema;
};

declare const INNER_HANDLE_MARKER = "inner";

declare type InnerHandleId = `${OuterHandleId}:${InnerHandleMarker}:${NodeEntityId}`;

declare type InnerHandleMarker = typeof INNER_HANDLE_MARKER;

/**
 * Canonical persistable shape of a workflow document. Returned by
 * {@link getStoreDataForIntegration} and passed to the host's save
 * callback under the `'props'` strategy.
 *
 * @category Integration
 */
export declare type IntegrationDataFormat = {
    name: string;
    globalVariables: VariablesIndex;
    layoutDirection: LayoutDirection;
    nodes: WorkflowBuilderNode[];
    edges: WorkflowBuilderEdge[];
};

/**
 * Same shape as {@link IntegrationDataFormat} but with every field
 * optional — accepted by load callbacks that may only deliver a partial
 * payload (e.g. just nodes + edges, layoutDirection inferred).
 *
 * @category Integration
 */
export declare type IntegrationDataFormatOptional = Partial<IntegrationDataFormat>;

/**
 * Persistence strategy identifier — one of:
 *
 * - `'localStorage'`: editor reads / writes the diagram under a fixed
 *   `'workflowBuilderDiagram'` key in browser `localStorage` (not
 *   derived from the instance `name` prop). Default.
 * - `'api'`: editor performs HTTP load + save against the configured
 *   `endpoints.load` / `endpoints.save` URLs.
 * - `'props'`: editor calls the host-supplied `onDataSave` callback;
 *   initial state comes from `initialNodes` / `initialEdges` props.
 *
 * @category Integration
 */
export declare type IntegrationStrategy = 'localStorage' | 'api' | 'props';

/**
 * Tester matching any control element.
 * @category Forms
 */
export declare const isControl: (uischema: any) => uischema is JsonFormsCore.ControlElement;

/**
 * Tester matching any layout element.
 * @category Forms
 */
export declare const isLayout: (uischema: JsonFormsCore.UISchemaElement) => uischema is JsonFormsCore.Layout;

declare type ItemOption = {
    label: string;
    value: string;
    icon?: IconType;
    type?: 'item';
};

/**
 * Custom JsonForms cell renderer — like
 * {@link JsonFormsRendererExtension} but for cell-level rendering inside
 * table-style controls.
 *
 * @category Plugins
 */
export declare type JsonFormsCellExtension = JsonFormsCellRendererRegistryEntry;

/**
 * Renders a nested uischema subtree from a custom layout renderer.
 * @category Forms
 */
export declare const JsonFormsDispatch: ComponentType<JsonFormsCore.OwnPropsOfJsonFormsRenderer>;

/**
 * Custom JsonForms renderer entry — a `tester` predicate paired with the
 * React component that renders matching schemas. Use it to plug a
 * domain-specific control (e.g. a colour picker, code editor) into the
 * property panel.
 *
 * @category Plugins
 */
export declare type JsonFormsRendererExtension = JsonFormsRendererRegistryEntry;

/**
 * A JSON Schema, as used for node property schemas.
 * @category Forms
 */
export declare type JsonSchema = JsonFormsCore.JsonSchema;

/**
 * Default edge component for the diagram. Renders a smooth-step path
 * between two nodes, mounts an {@link EdgeLabel} at the midpoint when
 * `data.label` or `data.icon` is set, and degrades to a self-connecting
 * loop when source and target are the same node.
 *
 * Registered automatically as the `'labelEdge'` type — to use it in your
 * own diagrams, set `edge.type = 'labelEdge'` and put a label / icon in
 * `edge.data`.
 *
 * @category Components
 */
export declare function LabelEdge({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, data, selected, source, target, }: EdgeProps<WorkflowBuilderEdge>): JSX.Element;

declare type LabelElement = Override<LabelElement_2, LabelOwnProps>;

declare type LabelOwnProps = {
    required?: boolean;
    size?: ItemSize;
    variant?: LabelVariant;
};

/**
 * Props injected into a custom label renderer.
 * @category Forms
 */
export declare type LabelProps = JsonFormsCore.LabelProps;

declare type LabelVariant = 'default' | 'title';

/**
 * A uischema layout element.
 * @category Forms
 */
export declare type Layout = JsonFormsCore.Layout;

/**
 * Optional side effects for a layout-direction *toggle*.
 *
 * @category Hooks
 */
export declare type LayoutChangeOptions = {
    /**
     * Also reflow node positions by swapping each node's `x`/`y`, so the diagram
     * visually re-lays-out along the new axis. Defaults to `false` (handles and
     * edges re-orient, coordinates stay put). This is a naive mirror, not a
     * layout algorithm: it ignores node dimensions, so non-square nodes shift
     * relative to their neighbours. Pair it with `fitView` and treat it as a
     * quick approximation, not production auto-layout.
     */
    flipPositions?: boolean;
    /** Animate the view to fit all nodes after the change. Defaults to `false`. */
    fitView?: boolean;
};

/**
 * Diagram flow direction. `'RIGHT'` arranges nodes left→right (default
 * for horizontal workflows); `'DOWN'` arranges them top→bottom.
 *
 * @category Types
 */
export declare type LayoutDirection = (typeof layoutDirections)[number];

declare const layoutDirections: readonly ["DOWN", "RIGHT"];

/**
 * Props injected into a custom layout renderer.
 * @category Forms
 */
export declare type LayoutProps = JsonFormsCore.LayoutProps;

declare type LogicalOperator = 'OR' | 'AND';

declare type MakePropertiesOptional<T> = {
    [K in keyof T]?: T[K];
};

declare type MessageOnErrorControlElement = Override<BaseControlElement, {
    type: 'MessageOnError';
    text?: string;
    variant?: 'info' | 'warning' | 'error';
}>;

declare type ModalProps = {
    content: ComponentProps<typeof Modal>['children'];
    icon?: ComponentProps<typeof Modal>['icon'];
    title: string;
    footer?: ComponentProps<typeof Modal>['footer'];
    isCloseButtonVisible?: boolean;
    footerVariant?: FooterVariant;
    onModalClosed?: () => void;
};

declare type ModifyProps<P> = (props: P) => P;

/**
 * Callback signature for {@link addNodeChangedListener}. Receives every
 * node change xyflow emits (position, dimensions, selection, …) before
 * the store updates.
 *
 * @category Listeners
 */
export declare type NodeChangedListener = (changes: NodeChange[]) => void;

/**
 * Per-node data attached to every {@link WorkflowBuilderNode}. The `properties`
 * field carries the node's user-editable values (typed by `T`); `type`
 * matches the corresponding `NodeDefinition.type`; `icon` is the icon shown
 * in palette and on the diagram canvas.
 *
 * Generic over `T` so concrete node types can refine `properties` to their
 * own schema-driven shape (typically via `NodeDataProperties<MySchema>`).
 *
 * @category Types
 */
export declare type NodeData<T = BaseNodeProperties & Record<string, unknown>> = {
    segments?: [];
    templateType?: NodeType;
    properties: T;
    icon: IconType;
    type: string;
};

/**
 * Derives a TypeScript type for a node's `data.properties` directly from
 * its {@link NodeSchema}. Each property is optional (matching the
 * runtime, where partial form-state is normal).
 *
 * @example
 * ```ts
 * const schema = { type: 'object', properties: { count: { type: 'number' } } } as const;
 * type Props = NodeDataProperties<typeof schema>; // { count?: number }
 * ```
 *
 * @category Types
 */
export declare type NodeDataProperties<T> = MakePropertiesOptional<ExtractProperties<T>>;

declare type NodeDefinition<T extends NodeSchema> = {
    schema: T;
    /** default values of schema based properties */
    defaultPropertiesData: NodeDataProperties<T>;
    /** describes how the form looks like and to which fields data properties should be mapped */
    uischema?: UISchema;
    /** describes the output properties this node produces, used by the variable picker */
    outputSchema?: NodeOutputSchema;
} & Required<Omit<BaseNodeProperties, 'errors' | 'customErrors'>> & Pick<NodeData, 'type' | 'icon' | 'templateType'>;

declare type NodeEntityId = string;

declare type NodeOutputSchema = NodeOutputSchemaDefault | NodeOutputSchemaVariant;

declare type NodeOutputSchemaDefault = {
    type: 'default';
    properties: OutputPropertiesIndex;
};

declare type NodeOutputSchemaVariant = {
    type: 'variant';
    variants: {
        [variantName: string]: OutputVariant | undefined;
    };
};

declare type NodePropertiesSchema = BaseNodePropertiesSchema & Record<string, FieldSchema>;

/**
 * JSON-schema-like description of a node type's editable properties.
 *
 * Drives three things at runtime:
 *
 * 1. **Validation** — values are checked against this shape; failures bubble
 *    into `NodeData.properties.errors` for UI display.
 * 2. **Rendering** — JsonForms uses the schema (combined with an optional
 *    {@link UISchema}) to render the property panel.
 * 3. **Type inference** — `NodeDataProperties<MySchema>` extracts a precise
 *    TypeScript type for a node's `properties`.
 *
 * @category Types
 */
export declare type NodeSchema = ObjectFieldRequiredValidationSchema & {
    properties: NodePropertiesSchema;
    allOf?: IfThenElseSchema[];
};

/**
 * Visually-grouped container used inside custom node bodies — renders a
 * header label above its children with the editor's section spacing and
 * border tokens.
 *
 * Reach for it when authoring a node template that needs to split its
 * content into named sub-blocks (e.g. "Inputs", "Settings").
 *
 * @category Components
 */
export declare function NodeSection({ label, children }: Props_2): JSX.Element;

/**
 * Built-in template categories the editor recognises. Drives diagram
 * validation rules (e.g. exactly one start node, decision branches),
 * the variable picker's traversal, and rendering choices in the default
 * node template.
 *
 * Custom node types declare their template type via this enum so the
 * editor can apply the matching rules.
 *
 * @category Types
 */
export declare enum NodeType {
    Node = "node",
    StartNode = "start-node",
    AiNode = "ai-node",
    DecisionNode = "decision-node"
}

/**
 * Negates a tester.
 * @category Forms
 */
export declare const not: (tester: JsonFormsCore.Tester) => JsonFormsCore.Tester;

declare type NumberFieldSchema = BaseFieldSchema & NumberFieldValidationSchema;

declare type NumberFieldValidationSchema = {
    type: 'number';
    minimum?: number;
    maximum?: number;
    exclusiveMinimum?: number;
    exclusiveMaximum?: number;
    multipleOf?: number;
};

declare type ObjectFieldRequiredValidationSchema = {
    type?: 'object';
    required?: string[];
};

declare type ObjectFieldSchema = BaseFieldSchema & ObjectFieldRequiredValidationSchema & {
    type: 'object';
    properties: Record<string, FieldSchema>;
};

declare type ObjectFieldValidationSchema = ObjectFieldRequiredValidationSchema & {
    properties: Record<string, FieldValidationSchema>;
};

/**
 * Save callback shape the host supplies under the `'props'` integration
 * strategy. The editor calls it with the current diagram payload and
 * expects a {@link DidSaveStatus} resolution.
 *
 * @category Integration
 */
export declare type OnSaveExternal = (data: IntegrationDataFormat, savingParams?: OnSaveParams) => Promise<DidSaveStatus>;

/**
 * Optional metadata passed to save callbacks. Today only `isAutoSave`
 * exists — the host can use it to suppress UI feedback on autosaves.
 *
 * @category Integration
 */
export declare type OnSaveParams = {
    isAutoSave?: boolean;
};

/**
 * Open a modal dialog with the given content + optional title / icon /
 * footer. Resolves through the editor's modal registry (one modal at a
 * time; calling `openModal` while one is already visible replaces it).
 *
 * Use it from a plugin to render a confirmation dialog, a settings
 * picker, or any custom UI gated behind a button.
 *
 * @category Store
 */
export declare function openModal({ isCloseButtonVisible, footerVariant, ...restProps }: ModalProps): void;

/**
 * Single entry in a Select control's option list — either an item
 * (label + value, optionally an icon) or a visual separator.
 *
 * @category Types
 */
declare type Option_2 = ItemOption | SeparatorOption;
export { Option_2 as Option }

/**
 * Plugin slot mounted inside every node body. By default renders its
 * children unchanged; plugins can attach extra UI here via
 * {@link registerComponentDecorator} keyed `'OptionalNodeContent'`.
 *
 * The slot receives `nodeId` so decorators can scope their content to
 * specific nodes (e.g. show a status badge only on certain types).
 *
 * @category Components
 */
export declare const OptionalNodeContent: MemoExoticComponent<(props: PropsWithChildren<Props_3>) => JSX.Element>;

/**
 * Tester matching by a uischema element `options` value.
 * @category Forms
 */
export declare const optionIs: (optionName: string, optionValue: any) => JsonFormsCore.Tester;

declare type Options = {
    withControlOrMeta?: boolean;
    skipTarget?: boolean;
};

/**
 * Combines testers — matches when any match.
 * @category Forms
 */
export declare const or: (...testers: JsonFormsCore.Tester[]) => JsonFormsCore.Tester;

declare type OuterHandleId = HandleType;

declare type OutputPropertiesIndex = Record<string, OutputProperty>;

declare type OutputProperty = {
    type: VariableType;
    label: string;
    description?: string;
};

declare type OutputVariant = {
    variantRule: undefined | {
        dataPropertyName: string;
        dataPropertyValue: string;
    };
    properties: OutputPropertiesIndex;
};

declare type Override<A, B> = Omit<A, keyof B> & B;

declare type PaletteGroup = {
    label: string;
    groupItems: PaletteItem[];
    isOpen?: boolean;
};

/**
 * One entry in the editor's left-hand palette — equivalent to a full
 * node definition (schema, default values, icon, type id). Drag onto
 * the canvas to instantiate the corresponding node.
 *
 * @category Types
 */
export declare type PaletteItem<T extends NodeSchema = NodeSchema> = NodeDefinition<T>;

/**
 * Either a single {@link PaletteItem} or a labelled group of them
 * (`PaletteGroup`). `<WorkflowBuilder.Root nodeTypes={...} />` accepts a
 * mixed array of both forms.
 *
 * @category Types
 */
export declare type PaletteItemOrGroup = PaletteItem | PaletteGroup;

declare type PaletteState = {
    isSidebarExpanded: boolean;
    data: PaletteItemOrGroup[];
    fetchDataStatus: StatusType;
    draggedItem: DraggingItem | null;
    toggleSidebar: (value?: boolean) => void;
    fetchData: () => void;
    setDraggedItem: (item: DraggingItem | null) => void;
    getNodeDefinition: (nodeType: string) => PaletteItem | undefined;
};

/**
 * i18next-shaped resource bundle accepted by
 * {@link registerPluginTranslation}. Every plugin's strings live under
 * `translation.plugins.<pluginName>` to namespace away from SDK keys.
 *
 * @category Plugins
 */
export declare type PluginTranslationResource = {
    [lang: string]: {
        translation: {
            [key: string]: {
                [key: string]: string | {
                    [key: string]: string;
                };
            };
        };
    };
};

/**
 * Forces TypeScript to flatten an intersection / mapped type into a
 * single object literal. Doesn't change semantics — only what TS shows
 * in tooltips and error messages.
 *
 * @category Utilities
 */
export declare type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type PrimitiveFieldSchema = (StringFieldSchema | NumberFieldSchema | BooleanFieldSchema) & {
    options?: Option_2[];
};

declare type PrimitiveFieldType = 'string' | 'number' | 'boolean';

/* Excluded from this release type: ProjectSelection */

/**
 * Props accepted by {@link ProjectSelection}. Use this when typing a
 * `registerComponentDecorator<ProjectSelectionProps>('ProjectSelection', …)`
 * call.
 *
 * @category Components
 */
export declare type ProjectSelectionProps = {
    /**
     * Optional handler for the kebab menu's "Duplicate to Drafts" item. The item
     * is rendered only when this is provided — omit it and the item is absent.
     */
    onDuplicateClick?: () => void;
};

/* Excluded from this release type: PropertiesBar */

declare type PropertiesBarBaseProps = {
    selection: SingleSelectedElement | null;
    selectedTab: string;
};

declare type PropertiesBarItem = {
    when: (props: PropertiesBarSelection) => boolean;
    component: (props: PropertiesBarSelection) => React.ReactNode;
};

/**
 * Props accepted by {@link PropertiesBar}.
 *
 * Provide localized labels (`headerLabel`, `deleteNodeLabel`,
 * `deleteEdgeLabel`), the active tab + change handler, the delete handler,
 * and an optional `tabs` array for extra tabs alongside the default
 * "Properties" tab.
 *
 * @category Components
 */
export declare type PropertiesBarProps = PropertiesBarBaseProps & {
    headerLabel: string;
    deleteNodeLabel: string;
    deleteEdgeLabel: string;
    tabs?: PropertiesBarTab[];
    onTabChange: (tab: string) => void;
    onMenuHeaderClick?: () => void;
    onDeleteClick: () => void;
};

declare type PropertiesBarSelection = Omit<PropertiesBarBaseProps, 'selection'> & {
    selection: SingleSelectedElement;
};

declare type PropertiesBarTab = {
    label: string;
    value: string;
    components: PropertiesBarItem[];
};

declare type PropertyPath<T> = T extends object ? {
    [K in keyof T]: K extends string ? T[K] extends Array<unknown> ? K : T[K] extends object ? // If property is an object, allow deeper paths
    K | `${K}.${PropertyPath<T[K]>}` : K : never;
}[keyof T] : never;

declare type Props = {
    label: string;
    className?: string;
    required?: boolean;
    size?: ItemSize;
};

declare type Props_2 = PropsWithChildren<{
    label: string;
}>;

declare type Props_3 = {
    nodeId: string;
};

/**
 * A tester paired with its rank, as returned by {@link rankWith}.
 * @category Forms
 */
export declare type RankedTester = JsonFormsCore.RankedTester;

/**
 * Assigns a priority to a tester; rank above the built-ins to override a control.
 * @category Forms
 */
export declare const rankWith: (rank: number, tester: JsonFormsCore.Tester) => (uischema: JsonFormsCore.UISchemaElement, schema: JsonFormsCore.JsonSchema, context: JsonFormsCore.TesterContext) => number;

/**
 * Decorate a named slot — add UI before/after/around it or transform its props.
 *
 * Slots are mount points the SDK exposes for plugins to inject custom UI
 * without forking the editor. Common slots include `'OptionalAppBarControls'`,
 * `'OptionalNodeContent'`, and others — see the
 * [Build a plugin](/docs/guides/build-a-plugin/) guide for the authoritative
 * list.
 *
 * Safe to call more than once; pass `plugin.name` to deduplicate.
 *
 * @param componentName - Slot identifier (e.g. `'OptionalAppBarControls'`).
 * @param plugin - Decorator configuration. See {@link ComponentDecoratorOptions}.
 *
 * @example
 * ```ts
 * registerComponentDecorator('OptionalAppBarControls', {
 *   content: MyButton,
 *   place: 'after',
 *   name: 'analytics-button',
 * });
 * ```
 *
 * @category Plugins
 */
export declare function registerComponentDecorator<P>(componentName: string, plugin: ComponentDecoratorOptions<P>): void;

/**
 * Decorate a named SDK function — observe its calls or transform its
 * arguments / return value without forking.
 *
 * Common decoration targets: `'trackFutureChange'` (state-mutation tracking),
 * diagram-listener emitters, save callbacks. See the
 * [Build a plugin](/docs/guides/build-a-plugin/) guide for the authoritative
 * list of decoratable functions.
 *
 * Safe to call more than once; pass `plugin.name` to deduplicate.
 *
 * @example
 * ```ts
 * registerFunctionDecorator('trackFutureChange', {
 *   place: 'after',
 *   callback: ({ params }) => auditLog(params),
 *   name: 'audit-log',
 * });
 * ```
 *
 * @category Plugins
 */
export declare function registerFunctionDecorator(functionName: string, plugin: FunctionDecoratorOptions): void;

/**
 * Merge plugin translations into the SDK's i18next instance.
 *
 * Resources follow the i18next shape `{ [lang]: { translation: { plugins: {...} } } }`
 * — every plugin's strings live under the `plugins` namespace, scoped by
 * plugin name to avoid key collisions.
 *
 * Safe to call more than once and at any time relative to i18next init: each
 * call also issues `i18n.addResourceBundle(...)` so newly registered strings
 * surface live, even when the plugin registers after the SDK has already
 * initialised i18next.
 *
 * @example
 * ```ts
 * registerPluginTranslation({
 *   en: { translation: { plugins: { myPlugin: { hello: 'Hello' } } } },
 *   pl: { translation: { plugins: { myPlugin: { hello: 'Cześć' } } } },
 * });
 * ```
 *
 * @category Plugins
 */
export declare function registerPluginTranslation(pluginResourceToAdd: Resource): void;

/**
 * Remove a previously-registered node-change listener.
 *
 * @category Listeners
 */
export declare function removeNodeChangedListener(listener: NodeChangedListener): void;

/**
 * Remove a previously-registered node-drag-start listener.
 *
 * @category Listeners
 */
export declare function removeNodeDragStartListener(listener: OnNodeDrag): void;

/**
 * Clear all node + edge selection. The diagram updates to the
 * unselected visual state on next render.
 *
 * @category Store
 */
export declare function resetStoreSelection(): void;

declare type Resource = {
    [lang: string]: {
        translation: {
            [key: string]: {
                [key: string]: string | {
                    [key: string]: string;
                };
            };
        };
    };
};

declare type RichTextElement = Override<LabelElement_2, LabelOwnProps & {
    type: 'RichText';
}>;

/**
 * Rule effect for conditional uischema rules (`SHOW`, `HIDE`, `ENABLE`, `DISABLE`).
 * @category Forms
 */
export declare const RuleEffect: typeof JsonFormsCore.RuleEffect;

export declare type RuleEffect = JsonFormsCore.RuleEffect;

declare type SchemaCondition = {
    properties: Record<string, {
        const?: string | number | boolean;
    }>;
};

/**
 * Tester matching when the bound schema fragment satisfies a predicate.
 * @category Forms
 */
export declare const schemaMatches: (predicate: (schema: JsonFormsCore.JsonSchema, rootSchema: JsonFormsCore.JsonSchema) => boolean) => JsonFormsCore.Tester;

/**
 * Tester matching by the bound schema's `type`.
 * @category Forms
 */
export declare const schemaTypeIs: (expectedType: string) => JsonFormsCore.Tester;

/**
 * Tester matching when the control's `scope` ends with a fragment.
 * @category Forms
 */
export declare const scopeEndsWith: (expected: string) => JsonFormsCore.Tester;

/**
 * ReactFlow props the SDK sets itself (spread last in `diagram.tsx`, so they win
 * over `reactFlowProps`) and omits from {@link WorkflowBuilderReactFlowProps}.
 * The `diagram.spec` precedence test enforces each one stays owned. Internal:
 * exported for that test only.
 */
declare type SdkManagedReactFlowKey = 'nodes' | 'edges' | 'nodeTypes' | 'edgeTypes' | 'onConnect' | 'onConnectStart' | 'onConnectEnd' | 'onNodesChange' | 'onEdgesChange' | 'onSelectionChange' | 'onInit' | 'onBeforeDelete' | 'onNodeDragStart' | 'onNodeDragStop' | 'onEdgeMouseEnter' | 'onEdgeMouseLeave' | 'onDragOver' | 'onDrop' | 'connectionLineComponent' | 'nodesConnectable' | 'nodesDraggable' | 'isValidConnection';

/** Every ReactFlow key the escape hatch must not expose. */
declare type SdkOwnedReactFlowKey = SdkManagedReactFlowKey | SdkReservedReactFlowKey;

/**
 * ReactFlow props omitted from {@link WorkflowBuilderReactFlowProps} but not
 * re-set in `diagram.tsx`. `default*` are no-ops under the SDK's controlled
 * `nodes` / `edges`; `colorMode` would clash with the SDK theme. Type-level guard
 * only (a JS / `as`-cast consumer can still smuggle them; worst case is cosmetic).
 */
declare type SdkReservedReactFlowKey = 'defaultNodes' | 'defaultEdges' | 'colorMode';

declare type SelectControlElement = Override<BaseControlElement, {
    type: 'Select';
}>;

/**
 * Vertical distance (px) between the source node's top edge and the
 * apex of a self-connecting edge's loop. Also drives where the edge's
 * label sits on a self-connecting edge.
 *
 * @category Constants
 */
export declare const SELF_CONNECTING_EDGE_LABEL_OFFSET = 100;

/**
 * Edge that loops above the source node when source and target are the
 * same node (a "self-connecting" or "back-to-self" edge). Draws a
 * rounded-corner path that arches over the node so the loop stays visible
 * regardless of the node's size.
 *
 * Used internally by {@link LabelEdge}; expose only when you author a
 * custom edge type and want to reuse the same loop geometry.
 *
 * @category Components
 */
export declare function SelfConnectingEdge({ id, sourceX, sourceY, targetX, targetY, selected, hovered, nodeHeight, }: SelfConnectingEdgeProps): JSX.Element;

declare type SelfConnectingEdgeProps = EdgeProps<WorkflowBuilderEdge> & {
    nodeHeight?: number;
    hovered: boolean;
};

declare type SeparatorOption = {
    type: 'separator';
};

/**
 * Replace all edges in the store with the given list.
 *
 * @category Store
 */
export declare function setStoreEdges(edges: WorkflowBuilderEdge[]): void;

/**
 * Set the diagram layout direction. Re-rendering picks up the new
 * direction without recomputing the layout — call your auto-layout helper
 * after this if positions need to update.
 *
 * @category Store
 */
export declare function setStoreLayoutDirection(layoutDirection: LayoutDirection): void;

/**
 * Replace all nodes in the store with the given list. Each node is
 * re-validated against its schema before committing — `properties.errors`
 * on the resulting nodes reflects the new validation state.
 *
 * @category Store
 */
export declare function setStoreNodes(nodes: WorkflowBuilderNode[]): void;

declare type SharedDecoratorOptions<Props = object> = {
    modifyProps?: ModifyProps<Props>;
    priority?: number;
    name?: string;
};

declare type SharedDecoratorOptions_2 = {
    priority?: number;
    name?: string;
};

/**
 * Reusable schema fragment for the properties every node carries by default:
 * `label` and `description`. Spread this into a custom
 * `NodeSchema['properties']` to avoid redeclaring them per node type.
 *
 * @category Utilities
 */
export declare const sharedProperties: BaseNodePropertiesSchema;

declare type SingleSelectedElement = {
    node: WorkflowBuilderNode | null;
    edge: WorkflowBuilderEdge | null;
};

declare type Size = 'extra-large' | 'large' | 'medium' | 'small';

/**
 * Canonical option set for the node-status select control: `active`,
 * `draft`, `disabled`. Each option ships its `label`, `value`, and the
 * matching status icon name.
 *
 * @category Utilities
 */
export declare const statusOptions: {
    readonly active: {
        readonly label: "Active";
        readonly value: "active";
        readonly icon: "StatusActive";
    };
    readonly draft: {
        readonly label: "Draft";
        readonly value: "draft";
        readonly icon: "StatusDraft";
    };
    readonly disabled: {
        readonly label: "Disabled";
        readonly value: "disabled";
        readonly icon: "StatusDisabled";
    };
};

declare enum StatusType {
    Idle = "idle",
    Loading = "loading",
    Success = "success",
    Error = "error"
}

declare type StringFieldSchema = BaseFieldSchema & StringFieldValidationSchema;

declare type StringFieldValidationSchema = {
    type: 'string';
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    format?: string;
};

declare type SwitchControlElement = Override<BaseControlElement, {
    type: 'Switch';
}>;

/**
 * Code-editor input with syntax highlighting. Lazy-loads the heavy
 * `ace-builds` chunk — until it arrives, falls back to a plain `<TextArea>`
 * so the consumer never sees a blank tile during the load.
 *
 * Use it inside custom JsonForms renderers when a property accepts code
 * (JSON, JS expressions, etc.). Pass `mode` to pick the highlighter
 * grammar (`'json'`, `'javascript'`, …) and `value` / `onChange` to wire
 * it to your form state.
 *
 * @category Components
 */
export declare function SyntaxHighlighterLazy(props: SyntaxHighlighterLazyProps): JSX.Element;

declare type SyntaxHighlighterLazyProps = SyntaxHighlighterProps;

declare type SyntaxHighlighterProps = {
    value: string;
    onChange?: (value?: string) => void;
    isDisabled?: boolean;
    mode?: string;
};

/**
 * One entry in the editor's template selector — pairs a {@link DiagramModel}
 * with display metadata (id, name, icon). Pass an array of these to
 * `<WorkflowBuilder.Root diagramTemplates={...} />` to populate the selector.
 *
 * @category Types
 */
export declare type TemplateModel = {
    id: number;
    name: string;
    value: DiagramModel;
    icon: IconType;
};

/**
 * A renderer/cell matcher function.
 * @category Forms
 */
export declare type Tester = JsonFormsCore.Tester;

declare type TextAreaControlElement = Override<BaseControlElement, {
    type: 'TextArea';
} & Pick<TextAreaProps, 'placeholder' | 'minRows' | 'maxRows'>>;

declare type TextControlElement = Override<BaseControlElement, {
    type: 'Text';
    inputType?: string;
} & Pick<InputProps, 'placeholder'>>;

export declare type Theme = 'dark' | 'light';

/**
 * Mark that a tracked change is about to occur. Updates the
 * {@link useChangesTrackerStore} so subscribers see the new
 * `lastChangeName` / `lastChangeTimestamp`.
 *
 * Wrapped with `withOptionalFunctionPlugins`, so plugins can decorate it
 * via {@link registerFunctionDecorator} keyed `'trackFutureChange'` to
 * observe or transform every change before it reaches the store.
 *
 * @param changeName - Identifier of the impending change (e.g.
 *   `'addEdge'`, `'nodeDragStart'`, `'delete'`).
 * @param params - Optional metadata about the change.
 *
 * @category Store
 */
export declare const trackFutureChange: (changeName: string, params?: object | undefined) => void;

export { TranslationKey }

declare type TypeMap = {
    string: string;
    number: number;
    boolean: boolean;
};

/**
 * JsonForms-compatible UI schema describing how a node's properties are
 * rendered in the property panel — controls (Text, Switch, Select,
 * DynamicConditions, …), layouts (Vertical, Horizontal, Group,
 * Accordion), and labels.
 *
 * Pair with {@link NodeSchema} to drive both validation and rendering
 * from a single declarative source.
 *
 * @category Types
 */
export declare type UISchema = UISchemaElement;

declare type UISchemaCondition = OrCondition | AndCondition | LeafCondition | SchemaBasedCondition;

declare type UISchemaControlElement<T extends string = string> = (TextControlElement | SwitchControlElement | SelectControlElement | DatePickerControlElement | TextAreaControlElement | DynamicConditionsControlElement | AiToolsControlElement | DecisionBranchesControlElement | VariableTextControlElement | VariableTextAreaControlElement | MessageOnErrorControlElement) & {
    scope: T;
    errorIndicatorEnabled?: boolean;
};

declare type UISchemaElement<T extends string = string> = UISchemaControlElement<T> | UISchemaLayoutElement | LabelElement | RichTextElement;

declare type UISchemaLayoutElement = GroupLayoutElement | AccordionLayoutElement | VerticalLayoutElement | HorizontalLayoutElement;

declare type UISchemaRule = {
    effect: keyof typeof RuleEffect_2;
    condition: UISchemaCondition;
};

/**
 * Tester matching a uischema element by its `type`.
 * @category Forms
 */
export declare const uiTypeIs: (expected: string) => JsonFormsCore.Tester;

/**
 * Zustand store that emits a tick every time a tracked diagram change is
 * about to happen. Subscribe with `useChangesTrackerStore((s) => s.lastChangeName)`
 * (or other fields) to react to changes — useful for undo/redo plugins,
 * autosave, audit logging, and so on.
 *
 * State shape: `{ lastChangeName, lastChangeParams, lastChangeTimestamp }`
 * — the timestamp is the cheapest field to subscribe to when you only
 * care about "something changed".
 *
 * @category Store
 */
export declare const useChangesTrackerStore: UseBoundStore<Omit<StoreApi<ChangesTrackerStore>, "setState"> & {
setState(partial: ChangesTrackerStore | Partial<ChangesTrackerStore> | ((state: ChangesTrackerStore) => ChangesTrackerStore | Partial<ChangesTrackerStore>), replace?: false | undefined, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
setState(state: ChangesTrackerStore | ((state: ChangesTrackerStore) => ChangesTrackerStore), replace: true, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
}>;

/**
 * Like `useEffect`, but skips the **first** run — the callback fires only
 * when one of the dependencies actually changes after the initial render.
 *
 * Useful when you want to react to user-driven changes without firing on
 * the initial mount (e.g. saving form edits to the server, but not the
 * initial seeded values).
 *
 * @param callback - Effect to run on dependency changes (post-mount).
 * @param dependencies - Dependency array, identical semantics to `useEffect`.
 *
 * @category Hooks
 */
export declare function useEffectChange(callback: () => void, dependencies: unknown[]): void;

/**
 * Returns a callback that animates the diagram view to fit all nodes,
 * accounting for the editor's app bar / palette / property panel bounds.
 *
 * Common triggers: after auto-layout, after loading a new diagram,
 * after a "fit view" toolbar button click. Uses a single
 * `requestAnimationFrame` so the call is safe to issue from a render path.
 *
 * @returns A `() => void` callback. Stable across renders unless the
 *   ReactFlow instance changes.
 *
 * @category Hooks
 */
export declare function useFitView(): () => void;

/**
 * Reads the full JsonForms state from inside a renderer.
 * @category Forms
 */
export declare const useJsonForms: () => JsonFormsReact.JsonFormsStateContext;

/**
 * Tracks whether a given key (or key combo) is currently held down.
 *
 * Defaults to firing only when the diagram canvas (body / `.react-flow__*`)
 * has focus — text inputs are excluded so typing in a property field
 * doesn't accidentally trigger keyboard shortcuts. Pass `skipTarget: true`
 * to listen globally and `withControlOrMeta: true` to require Ctrl / Cmd
 * to also be down.
 *
 * @param keyCode - xyflow `KeyCode` (single key string or combo).
 * @param options - Optional `skipTarget` / `withControlOrMeta` flags.
 * @returns `true` while the key is pressed; `false` otherwise.
 *
 * @category Hooks
 */
export declare function useKeyPress(keyCode: KeyCode, options?: Options): boolean;

/**
 * Tracks hover state for a single edge across both its line and its label
 * (which live in different React subtrees) and returns the resolved style
 * + handlers a custom edge component should bind.
 *
 * Suppresses hover while another edge is mid-segment-drag so the visual
 * doesn't flicker. Reach for it when authoring a custom edge type that
 * wants the same hover feel as the built-in {@link LabelEdge}.
 *
 * @category Hooks
 */
export declare function useLabelEdgeHover({ id, isSelected }: UseLabelEdgeHoverParams): {
    style: {
        stroke: string;
        strokeWidth: string;
        transition: string;
    };
    hovered: boolean;
    onMouseEnter: () => void;
    onMouseLeave: () => void;
};

declare type UseLabelEdgeHoverParams = {
    id: string;
    isSelected?: boolean;
};

/**
 * React-friendly variant of {@link addNodeChangedListener} with automatic
 * cleanup on unmount. Preferred over the raw `add` / `remove` pair for
 * components and providers — the SDK does NOT clear the listener registry
 * on `<WorkflowBuilder.Root>` remounts, so manual cleanup is mandatory and
 * easy to forget.
 *
 * The hook tolerates inline-arrow callbacks: a `useRef` trampoline keeps a
 * single stable subscription across re-renders while always invoking the
 * latest `listener` you passed. No need to wrap your callback in
 * `useCallback`.
 *
 * @example
 * ```tsx
 * function MyProvider() {
 *   useNodeChangedListener((changes) => {
 *     console.log('changes', changes);
 *   });
 *   return null;
 * }
 * ```
 *
 * @category Listeners
 */
export declare function useNodeChangedListener(listener: NodeChangedListener): void;

/**
 * React-friendly variant of {@link addNodeDragStartListener} with automatic
 * cleanup on unmount. Preferred over the raw `add` / `remove` pair — the
 * SDK does NOT clear the listener registry on `<WorkflowBuilder.Root>`
 * remounts, so manual cleanup is mandatory and easy to forget.
 *
 * The hook tolerates inline-arrow callbacks: a `useRef` trampoline keeps a
 * single stable subscription across re-renders while always invoking the
 * latest `listener` you passed. No need to wrap your callback in
 * `useCallback`.
 *
 * @category Listeners
 */
export declare function useNodeDragStartListener(listener: OnNodeDrag): void;

declare type UserPreferencesState = {
    shouldSkipShowingConfirmation: boolean;
    setShouldSkipShowDeleteConfirmation: (value: boolean) => void;
};

/**
 * Returns the currently-selected node + edge **only when exactly one
 * element is selected**, and `null` otherwise (zero selection or
 * multi-selection). Designed for the properties sidebar's "edit one thing
 * at a time" UI; the equality check tolerates stable references on
 * `node.data` / `edge.data` so the hook doesn't spam re-renders.
 *
 * @returns The selected element wrapped in `{ node, edge }` (each
 *   independently nullable), or `null` when selection isn't a single item.
 *
 * @category Hooks
 */
export declare function useSingleSelectedElement(): SingleSelectedElement | null;

/**
 * The SDK's Zustand store — a module-level **global singleton**.
 *
 * ## Why global (not per-Root)
 *
 * The SDK is single-instance by contract: mount one `<WorkflowBuilder.Root>`
 * per page (see README → "Single-instance constraint"). The plugin / i18n
 * registries and the palette/template config holders are already module-level
 * singletons, so the store is one too — a single, consistent lifetime model
 * instead of a per-Root store threaded through React context plus a
 * module-level "current" pointer kept in sync from a layout effect.
 *
 * This removes an entire bug class. Imperative reads (`useStore.getState()`
 * and the `getStore*` / `setStore*` action helpers built on it) used to throw
 * "store access before mount" when called during a descendant's render or
 * layout effect — i.e. before the Root's `useLayoutEffect` had a chance to
 * register the per-Root store. The store now exists from module load, so those
 * reads always resolve to a real (initially empty) state.
 *
 * `createWithEqualityFn` returns a hook that doubles as the store API:
 *   - subscribe with a selector — `const nodes = useStore((s) => s.nodes);`
 *   - read once, outside React — `useStore.getState()`
 *   - write / observe imperatively — `useStore.setState(...)`,
 *     `useStore.subscribe(...)`
 *
 * Equality is `shallow` by default, so selecting an object or array is safe.
 *
 * Sequential workflows (mount → save → unmount → mount next) get a clean slate
 * via {@link resetWorkflowStore}, which `<WorkflowBuilder.Root>` calls on mount
 * — the persistent global store would otherwise carry the previous diagram's
 * state into the next Root.
 *
 * @category Store
 */
export declare const useStore: UseBoundStoreWithEqualityFn<Omit<StoreApi<WorkflowEditorState>, "setState"> & {
setState(partial: WorkflowEditorState | Partial<WorkflowEditorState> | ((state: WorkflowEditorState) => WorkflowEditorState | Partial<WorkflowEditorState>), replace?: false | undefined, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
setState(state: WorkflowEditorState | ((state: WorkflowEditorState) => WorkflowEditorState), replace: true, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
}>;

/**
 * Returns a stable object of action callbacks: every command the built-in
 * `<WorkflowBuilder.TopBar />` offers, plus programmatic layout-direction
 * control. Use it from a custom header / toolbar when omitting the bar.
 *
 * Must be called from a descendant of `<WorkflowBuilder.Root>`; `save`
 * reads the active integration via React context.
 *
 * @example
 * ```tsx
 * function MyToolbar() {
 *   const actions = useWorkflowBuilderActions();
 *   return <button onClick={actions.save}>Save</button>;
 * }
 *
 * <WorkflowBuilder.Root>
 *   <MyToolbar />
 *   <WorkflowBuilder.Canvas />
 * </WorkflowBuilder.Root>
 * ```
 *
 * @category Hooks
 */
export declare function useWorkflowBuilderActions(): WorkflowBuilderActions;

/**
 * Reserved key under which the variable-text control looks up the
 * available upstream nodes when expanding `{{nodes.*}}` placeholders.
 * Plugins that compose alternative variable sources should namespace
 * their own keys to avoid colliding with this reserved value.
 *
 * @category Constants
 */
export declare const VARIABLE_NODES_KEY = "nodes";

declare type VariableDefinition = {
    id: string;
    name: string;
    type: VariableType_2;
    defaultValue: string;
    description: string;
};

declare type VariablesIndex = {
    [variableId: string]: VariableDefinition | undefined;
};

declare type VariableTextAreaControlElement = Override<BaseControlElement, {
    type: 'VariableTextArea';
} & Pick<TextAreaProps, 'placeholder' | 'minRows'>>;

declare type VariableTextControlElement = Override<BaseControlElement, {
    type: 'VariableText';
} & Pick<InputProps, 'placeholder'>>;

declare type VariableType = VariableTypePrimitive | 'object' | 'array';

declare type VariableType_2 = VariableTypePrimitive;

declare type VariableTypePrimitive = 'string' | 'number' | 'boolean' | 'datetime' | 'date';

declare type VerticalLayoutElement = Override<BaseLayoutElement, {
    type: 'VerticalLayout';
}>;

export declare type WBIcon = 'Acorn' | 'AddressBook' | 'AddressBookTabs' | 'AiAgent' | 'AirTrafficControl' | 'Airplane' | 'AirplaneInFlight' | 'AirplaneLanding' | 'AirplaneTakeoff' | 'AirplaneTaxiing' | 'AirplaneTilt' | 'Airplay' | 'AirtableLogo' | 'Alarm' | 'Alien' | 'AlignBottom' | 'AlignBottomSimple' | 'AlignCenterHorizontal' | 'AlignCenterHorizontalSimple' | 'AlignCenterVertical' | 'AlignCenterVerticalSimple' | 'AlignLeft' | 'AlignLeftSimple' | 'AlignRight' | 'AlignRightSimple' | 'AlignTop' | 'AlignTopSimple' | 'AmazonLogo' | 'Ambulance' | 'Anchor' | 'AnchorSimple' | 'AndroidLogo' | 'Angle' | 'AngularLogo' | 'Aperture' | 'AppStoreLogo' | 'AppWindow' | 'AppleLogo' | 'ApplePodcastsLogo' | 'ApproximateEquals' | 'Archive' | 'Armchair' | 'ArrowArcLeft' | 'ArrowArcRight' | 'ArrowBendDoubleUpLeft' | 'ArrowBendDoubleUpRight' | 'ArrowBendDownLeft' | 'ArrowBendDownRight' | 'ArrowBendLeftDown' | 'ArrowBendLeftUp' | 'ArrowBendRightDown' | 'ArrowBendRightUp' | 'ArrowBendUpLeft' | 'ArrowBendUpRight' | 'ArrowCircleDown' | 'ArrowCircleDownLeft' | 'ArrowCircleDownRight' | 'ArrowCircleLeft' | 'ArrowCircleRight' | 'ArrowCircleUp' | 'ArrowCircleUpLeft' | 'ArrowCircleUpRight' | 'ArrowClockwise' | 'ArrowCounterClockwise' | 'ArrowDown' | 'ArrowDownLeft' | 'ArrowDownRight' | 'ArrowElbowDownLeft' | 'ArrowElbowDownRight' | 'ArrowElbowLeft' | 'ArrowElbowLeftDown' | 'ArrowElbowLeftUp' | 'ArrowElbowRight' | 'ArrowElbowRightDown' | 'ArrowElbowRightUp' | 'ArrowElbowUpLeft' | 'ArrowElbowUpRight' | 'ArrowFatDown' | 'ArrowFatLeft' | 'ArrowFatLineDown' | 'ArrowFatLineLeft' | 'ArrowFatLineRight' | 'ArrowFatLineUp' | 'ArrowFatLinesDown' | 'ArrowFatLinesLeft' | 'ArrowFatLinesRight' | 'ArrowFatLinesUp' | 'ArrowFatRight' | 'ArrowFatUp' | 'ArrowLeft' | 'ArrowLineDown' | 'ArrowLineDownLeft' | 'ArrowLineDownRight' | 'ArrowLineLeft' | 'ArrowLineRight' | 'ArrowLineUp' | 'ArrowLineUpLeft' | 'ArrowLineUpRight' | 'ArrowRight' | 'ArrowSquareDown' | 'ArrowSquareDownLeft' | 'ArrowSquareDownRight' | 'ArrowSquareIn' | 'ArrowSquareLeft' | 'ArrowSquareOut' | 'ArrowSquareRight' | 'ArrowSquareUp' | 'ArrowSquareUpLeft' | 'ArrowSquareUpRight' | 'ArrowUDownLeft' | 'ArrowUDownRight' | 'ArrowULeftDown' | 'ArrowULeftUp' | 'ArrowURightDown' | 'ArrowURightUp' | 'ArrowUUpLeft' | 'ArrowUUpRight' | 'ArrowUp' | 'ArrowUpLeft' | 'ArrowUpRight' | 'ArrowsClockwise' | 'ArrowsCounterClockwise' | 'ArrowsDownUp' | 'ArrowsHorizontal' | 'ArrowsIn' | 'ArrowsInCardinal' | 'ArrowsInLineHorizontal' | 'ArrowsInLineVertical' | 'ArrowsInSimple' | 'ArrowsLeftRight' | 'ArrowsMerge' | 'ArrowsOut' | 'ArrowsOutCardinal' | 'ArrowsOutLineHorizontal' | 'ArrowsOutLineVertical' | 'ArrowsOutSimple' | 'ArrowsSplit' | 'ArrowsVertical' | 'Article' | 'ArticleMedium' | 'ArticleNyTimes' | 'Asclepius' | 'Asterisk' | 'AsteriskSimple' | 'At' | 'Atom' | 'Avocado' | 'Axe' | 'Baby' | 'BabyCarriage' | 'Backpack' | 'Backspace' | 'Bag' | 'BagSimple' | 'Balloon' | 'Bandaids' | 'Bank' | 'Barbell' | 'Barcode' | 'Barn' | 'Barricade' | 'Baseball' | 'BaseballCap' | 'BaseballHelmet' | 'Basket' | 'Basketball' | 'Bathtub' | 'BatteryCharging' | 'BatteryChargingVertical' | 'BatteryEmpty' | 'BatteryFull' | 'BatteryHigh' | 'BatteryLow' | 'BatteryMedium' | 'BatteryPlus' | 'BatteryPlusVertical' | 'BatteryVerticalEmpty' | 'BatteryVerticalFull' | 'BatteryVerticalHigh' | 'BatteryVerticalLow' | 'BatteryVerticalMedium' | 'BatteryWarning' | 'BatteryWarningVertical' | 'BeachBall' | 'Beanie' | 'Bed' | 'BeerBottle' | 'BeerStein' | 'BehanceLogo' | 'Bell' | 'BellRinging' | 'BellSimple' | 'BellSimpleRinging' | 'BellSimpleSlash' | 'BellSimpleZ' | 'BellSlash' | 'BellZ' | 'Belt' | 'BezierCurve' | 'Bicycle' | 'Binary' | 'Binoculars' | 'Biohazard' | 'Bird' | 'Blueprint' | 'Bluetooth' | 'BluetoothConnected' | 'BluetoothSlash' | 'BluetoothX' | 'Boat' | 'Bomb' | 'Bone' | 'Book' | 'BookBookmark' | 'BookOpen' | 'BookOpenText' | 'BookOpenUser' | 'Bookmark' | 'BookmarkSimple' | 'Bookmarks' | 'BookmarksSimple' | 'Books' | 'Boot' | 'Boules' | 'BoundingBox' | 'BowlFood' | 'BowlSteam' | 'BowlingBall' | 'BoxArrowDown' | 'BoxArrowUp' | 'BoxingGlove' | 'BracketsAngle' | 'BracketsCurly' | 'BracketsRound' | 'BracketsSquare' | 'Brain' | 'Brandy' | 'Bread' | 'Bridge' | 'Briefcase' | 'BriefcaseMetal' | 'Broadcast' | 'Broom' | 'Browser' | 'Browsers' | 'Bug' | 'BugBeetle' | 'BugDroid' | 'Building' | 'BuildingApartment' | 'BuildingOffice' | 'Buildings' | 'Bulldozer' | 'Bus' | 'Butterfly' | 'CableCar' | 'Cactus' | 'Cake' | 'Calculator' | 'Calendar' | 'CalendarBlank' | 'CalendarCheck' | 'CalendarDot' | 'CalendarDots' | 'CalendarHeart' | 'CalendarMinus' | 'CalendarPlus' | 'CalendarSlash' | 'CalendarStar' | 'CalendarX' | 'CallBell' | 'Camera' | 'CameraPlus' | 'CameraRotate' | 'CameraSlash' | 'Campfire' | 'Car' | 'CarBattery' | 'CarProfile' | 'CarSimple' | 'Cardholder' | 'Cards' | 'CardsThree' | 'CaretCircleDoubleDown' | 'CaretCircleDoubleLeft' | 'CaretCircleDoubleRight' | 'CaretCircleDoubleUp' | 'CaretCircleDown' | 'CaretCircleLeft' | 'CaretCircleRight' | 'CaretCircleUp' | 'CaretCircleUpDown' | 'CaretDoubleDown' | 'CaretDoubleLeft' | 'CaretDoubleRight' | 'CaretDoubleUp' | 'CaretDown' | 'CaretLeft' | 'CaretLineDown' | 'CaretLineLeft' | 'CaretLineRight' | 'CaretLineUp' | 'CaretRight' | 'CaretUp' | 'CaretUpDown' | 'Carrot' | 'CashRegister' | 'CassetteTape' | 'CastleTurret' | 'Cat' | 'CellSignalFull' | 'CellSignalHigh' | 'CellSignalLow' | 'CellSignalMedium' | 'CellSignalNone' | 'CellSignalSlash' | 'CellSignalX' | 'CellTower' | 'Certificate' | 'Chair' | 'Chalkboard' | 'ChalkboardSimple' | 'ChalkboardTeacher' | 'Champagne' | 'ChargingStation' | 'ChartBar' | 'ChartBarHorizontal' | 'ChartDonut' | 'ChartLine' | 'ChartLineDown' | 'ChartLineUp' | 'ChartPie' | 'ChartPieSlice' | 'ChartPolar' | 'ChartScatter' | 'Chat' | 'ChatCentered' | 'ChatCenteredDots' | 'ChatCenteredSlash' | 'ChatCenteredText' | 'ChatCircle' | 'ChatCircleDots' | 'ChatCircleSlash' | 'ChatCircleText' | 'ChatDots' | 'ChatSlash' | 'ChatTeardrop' | 'ChatTeardropDots' | 'ChatTeardropSlash' | 'ChatTeardropText' | 'ChatText' | 'Chats' | 'ChatsCircle' | 'ChatsTeardrop' | 'Check' | 'CheckCircle' | 'CheckFat' | 'CheckSquare' | 'CheckSquareOffset' | 'Checkerboard' | 'Checks' | 'Cheers' | 'Cheese' | 'ChefHat' | 'Cherries' | 'Church' | 'Cigarette' | 'CigaretteSlash' | 'Circle' | 'CircleDashed' | 'CircleHalf' | 'CircleHalfTilt' | 'CircleNotch' | 'CirclesFour' | 'CirclesThree' | 'CirclesThreePlus' | 'Circuitry' | 'City' | 'ClaudeLogo' | 'Clipboard' | 'ClipboardText' | 'Clock' | 'ClockAfternoon' | 'ClockClockwise' | 'ClockCountdown' | 'ClockCounterClockwise' | 'ClockUser' | 'ClosedCaptioning' | 'Cloud' | 'CloudArrowDown' | 'CloudArrowUp' | 'CloudCheck' | 'CloudFog' | 'CloudLightning' | 'CloudMoon' | 'CloudRain' | 'CloudSlash' | 'CloudSnow' | 'CloudSun' | 'CloudWarning' | 'CloudX' | 'Clover' | 'Club' | 'CoatHanger' | 'CodaLogo' | 'Code' | 'CodeBlock' | 'CodeSimple' | 'CodepenLogo' | 'CodesandboxLogo' | 'Coffee' | 'CoffeeBean' | 'Coin' | 'CoinVertical' | 'Coins' | 'Columns' | 'ColumnsPlusLeft' | 'ColumnsPlusRight' | 'Command' | 'Compass' | 'CompassRose' | 'CompassTool' | 'ComputerTower' | 'Confetti' | 'ContactlessPayment' | 'Control' | 'Cookie' | 'CookingPot' | 'Copy' | 'CopySimple' | 'Copyleft' | 'Copyright' | 'CornersIn' | 'CornersOut' | 'Couch' | 'CourtBasketball' | 'Cow' | 'CowboyHat' | 'Cpu' | 'Crane' | 'CraneTower' | 'CreditCard' | 'Cricket' | 'Crop' | 'Cross' | 'Crosshair' | 'CrosshairSimple' | 'Crown' | 'CrownCross' | 'CrownSimple' | 'Cube' | 'CubeFocus' | 'CubeTransparent' | 'CurrencyBtc' | 'CurrencyCircleDollar' | 'CurrencyCny' | 'CurrencyDollar' | 'CurrencyDollarSimple' | 'CurrencyEth' | 'CurrencyEur' | 'CurrencyGbp' | 'CurrencyInr' | 'CurrencyJpy' | 'CurrencyKrw' | 'CurrencyKzt' | 'CurrencyNgn' | 'CurrencyRub' | 'Cursor' | 'CursorClick' | 'CursorText' | 'Cylinder' | 'Database' | 'Desk' | 'Desktop' | 'DesktopTower' | 'Detective' | 'DevToLogo' | 'DeviceMobile' | 'DeviceMobileCamera' | 'DeviceMobileSlash' | 'DeviceMobileSpeaker' | 'DeviceRotate' | 'DeviceTablet' | 'DeviceTabletCamera' | 'DeviceTabletSpeaker' | 'Devices' | 'Diamond' | 'DiamondsFour' | 'DiceFive' | 'DiceFour' | 'DiceOne' | 'DiceSix' | 'DiceThree' | 'DiceTwo' | 'Disc' | 'DiscoBall' | 'DiscordLogo' | 'Divide' | 'Dna' | 'Dog' | 'Door' | 'DoorOpen' | 'Dot' | 'DotOutline' | 'DotsNine' | 'DotsSix' | 'DotsSixVertical' | 'DotsThree' | 'DotsThreeCircle' | 'DotsThreeCircleVertical' | 'DotsThreeOutline' | 'DotsThreeOutlineVertical' | 'DotsThreeVertical' | 'Download' | 'DownloadSimple' | 'Dress' | 'Dresser' | 'DribbbleLogo' | 'Drone' | 'Drop' | 'DropHalf' | 'DropHalfBottom' | 'DropSimple' | 'DropSlash' | 'DropboxLogo' | 'Ear' | 'EarSlash' | 'Egg' | 'EggCrack' | 'Eject' | 'EjectSimple' | 'Elevator' | 'Empty' | 'Engine' | 'Envelope' | 'EnvelopeOpen' | 'EnvelopeSimple' | 'EnvelopeSimpleOpen' | 'Equalizer' | 'Equals' | 'Eraser' | 'EscalatorDown' | 'EscalatorUp' | 'Exam' | 'ExclamationMark' | 'Exclude' | 'ExcludeSquare' | 'Export' | 'Eye' | 'EyeClosed' | 'EyeSlash' | 'Eyedropper' | 'EyedropperSample' | 'Eyeglasses' | 'Eyes' | 'FaceMask' | 'FacebookLogo' | 'Factory' | 'Faders' | 'FadersHorizontal' | 'FalloutShelter' | 'Fan' | 'Farm' | 'FastForward' | 'FastForwardCircle' | 'Feather' | 'FediverseLogo' | 'FigmaLogo' | 'File' | 'FileArchive' | 'FileArrowDown' | 'FileArrowUp' | 'FileAudio' | 'FileC' | 'FileCSharp' | 'FileCloud' | 'FileCode' | 'FileCpp' | 'FileCss' | 'FileCsv' | 'FileDashed' | 'FileDoc' | 'FileHtml' | 'FileImage' | 'FileIni' | 'FileJpg' | 'FileJs' | 'FileJsx' | 'FileLock' | 'FileMagnifyingGlass' | 'FileMd' | 'FileMinus' | 'FilePdf' | 'FilePlus' | 'FilePng' | 'FilePpt' | 'FilePy' | 'FileRs' | 'FileSql' | 'FileSvg' | 'FileText' | 'FileTs' | 'FileTsx' | 'FileTxt' | 'FileVideo' | 'FileVue' | 'FileX' | 'FileXls' | 'FileZip' | 'Files' | 'FilmReel' | 'FilmScript' | 'FilmSlate' | 'FilmStrip' | 'Fingerprint' | 'FingerprintSimple' | 'FinnTheHuman' | 'Fire' | 'FireExtinguisher' | 'FireSimple' | 'FireTruck' | 'FirstAid' | 'FirstAidKit' | 'Fish' | 'FishSimple' | 'Flag' | 'FlagBanner' | 'FlagBannerFold' | 'FlagCheckered' | 'FlagPennant' | 'Flame' | 'Flashlight' | 'Flask' | 'FlipHorizontal' | 'FlipVertical' | 'FloppyDisk' | 'FloppyDiskBack' | 'FlowArrow' | 'Flower' | 'FlowerLotus' | 'FlowerTulip' | 'FlyingSaucer' | 'Folder' | 'FolderDashed' | 'FolderLock' | 'FolderMinus' | 'FolderOpen' | 'FolderPlus' | 'FolderSimple' | 'FolderSimpleDashed' | 'FolderSimpleLock' | 'FolderSimpleMinus' | 'FolderSimplePlus' | 'FolderSimpleStar' | 'FolderSimpleUser' | 'FolderStar' | 'FolderUser' | 'Folders' | 'Football' | 'FootballHelmet' | 'Footprints' | 'ForkKnife' | 'FourK' | 'FrameCorners' | 'FramerLogo' | 'Function' | 'Funnel' | 'FunnelSimple' | 'FunnelSimpleX' | 'FunnelX' | 'GameController' | 'Garage' | 'GasCan' | 'GasPump' | 'Gauge' | 'Gavel' | 'Gear' | 'GearFine' | 'GearSix' | 'GeminiLogo' | 'GenderFemale' | 'GenderIntersex' | 'GenderMale' | 'GenderNeuter' | 'GenderNonbinary' | 'GenderTransgender' | 'Ghost' | 'Gif' | 'Gift' | 'GitBranch' | 'GitCommit' | 'GitDiff' | 'GitFork' | 'GitMerge' | 'GitPullRequest' | 'GithubLogo' | 'GitlabLogo' | 'GitlabLogoSimple' | 'Globe' | 'GlobeHemisphereEast' | 'GlobeHemisphereWest' | 'GlobeSimple' | 'GlobeSimpleX' | 'GlobeStand' | 'GlobeX' | 'Goggles' | 'Golf' | 'GoodreadsLogo' | 'GoogleCardboardLogo' | 'GoogleChromeLogo' | 'GoogleDriveLogo' | 'GoogleLogo' | 'GooglePhotosLogo' | 'GooglePlayLogo' | 'GooglePodcastsLogo' | 'Gps' | 'GpsFix' | 'GpsSlash' | 'Gradient' | 'GraduationCap' | 'Grains' | 'GrainsSlash' | 'Graph' | 'GraphicsCard' | 'GreaterThan' | 'GreaterThanOrEqual' | 'GridFour' | 'GridNine' | 'Guitar' | 'HairDryer' | 'Hamburger' | 'Hammer' | 'Hand' | 'HandArrowDown' | 'HandArrowUp' | 'HandCoins' | 'HandDeposit' | 'HandEye' | 'HandFist' | 'HandGrabbing' | 'HandHeart' | 'HandPalm' | 'HandPeace' | 'HandPointing' | 'HandSoap' | 'HandSwipeLeft' | 'HandSwipeRight' | 'HandTap' | 'HandWaving' | 'HandWithdraw' | 'Handbag' | 'HandbagSimple' | 'HandsClapping' | 'HandsPraying' | 'Handshake' | 'HardDrive' | 'HardDrives' | 'HardHat' | 'Hash' | 'HashStraight' | 'HeadCircuit' | 'Headlights' | 'Headphones' | 'Headset' | 'Heart' | 'HeartBreak' | 'HeartHalf' | 'HeartStraight' | 'HeartStraightBreak' | 'Heartbeat' | 'Hexagon' | 'HighDefinition' | 'HighHeel' | 'Highlighter' | 'HighlighterCircle' | 'Hockey' | 'Hoodie' | 'Horse' | 'Hospital' | 'Hourglass' | 'HourglassHigh' | 'HourglassLow' | 'HourglassMedium' | 'HourglassSimple' | 'HourglassSimpleHigh' | 'HourglassSimpleLow' | 'HourglassSimpleMedium' | 'House' | 'HouseLine' | 'HouseSimple' | 'HubspotLogo' | 'Hurricane' | 'IceCream' | 'IdentificationBadge' | 'IdentificationCard' | 'Image' | 'ImageBroken' | 'ImageSquare' | 'Images' | 'ImagesSquare' | 'Infinity' | 'Info' | 'InstagramLogo' | 'Intersect' | 'IntersectSquare' | 'IntersectThree' | 'Intersection' | 'Invoice' | 'Island' | 'Jar' | 'JarLabel' | 'Jeep' | 'JiraLogo' | 'Joystick' | 'Kanban' | 'Key' | 'KeyReturn' | 'Keyboard' | 'Keyhole' | 'Knife' | 'Ladder' | 'LadderSimple' | 'Lamp' | 'LampPendant' | 'Laptop' | 'Lasso' | 'LastfmLogo' | 'Layout' | 'Leaf' | 'Lectern' | 'Lego' | 'LegoSmiley' | 'LessThan' | 'LessThanOrEqual' | 'LetterCircleH' | 'LetterCircleP' | 'LetterCircleV' | 'Lifebuoy' | 'Lightbulb' | 'LightbulbFilament' | 'Lighthouse' | 'Lightning' | 'LightningA' | 'LightningSlash' | 'LineSegment' | 'LineSegments' | 'LineVertical' | 'Link' | 'LinkBreak' | 'LinkSimple' | 'LinkSimpleBreak' | 'LinkSimpleHorizontal' | 'LinkSimpleHorizontalBreak' | 'LinkedinLogo' | 'LinktreeLogo' | 'LinuxLogo' | 'List' | 'ListBullets' | 'ListChecks' | 'ListDashes' | 'ListHeart' | 'ListMagnifyingGlass' | 'ListNumbers' | 'ListPlus' | 'ListStar' | 'Lock' | 'LockKey' | 'LockKeyOpen' | 'LockLaminated' | 'LockLaminatedOpen' | 'LockOpen' | 'LockSimple' | 'LockSimpleOpen' | 'Lockers' | 'Log' | 'MagicWand' | 'Magnet' | 'MagnetStraight' | 'MagnifyingGlass' | 'MagnifyingGlassMinus' | 'MagnifyingGlassPlus' | 'Mailbox' | 'MapPin' | 'MapPinArea' | 'MapPinLine' | 'MapPinPlus' | 'MapPinSimple' | 'MapPinSimpleArea' | 'MapPinSimpleLine' | 'MapTrifold' | 'MarkdownLogo' | 'MarkerCircle' | 'Martini' | 'MaskHappy' | 'MaskSad' | 'MastodonLogo' | 'MathOperations' | 'MatrixLogo' | 'Medal' | 'MedalMilitary' | 'MediumLogo' | 'Megaphone' | 'MegaphoneSimple' | 'MemberOf' | 'Memory' | 'MessengerLogo' | 'MetaLogo' | 'Meteor' | 'Metronome' | 'Microphone' | 'MicrophoneSlash' | 'MicrophoneStage' | 'Microscope' | 'MicrosoftExcelLogo' | 'MicrosoftOutlookLogo' | 'MicrosoftPowerpointLogo' | 'MicrosoftTeamsLogo' | 'MicrosoftWordLogo' | 'Minus' | 'MinusCircle' | 'MinusSquare' | 'Money' | 'MoneyWavy' | 'Monitor' | 'MonitorArrowUp' | 'MonitorPlay' | 'Moon' | 'MoonStars' | 'Moped' | 'MopedFront' | 'Mosque' | 'Motorcycle' | 'Mountains' | 'Mouse' | 'MouseLeftClick' | 'MouseMiddleClick' | 'MouseRightClick' | 'MouseScroll' | 'MouseSimple' | 'MusicNote' | 'MusicNoteSimple' | 'MusicNotes' | 'MusicNotesMinus' | 'MusicNotesPlus' | 'MusicNotesSimple' | 'NavigationArrow' | 'Needle' | 'Network' | 'NetworkSlash' | 'NetworkX' | 'Newspaper' | 'NewspaperClipping' | 'NotEquals' | 'NotMemberOf' | 'NotSubsetOf' | 'NotSupersetOf' | 'Notches' | 'Note' | 'NoteBlank' | 'NotePencil' | 'Notebook' | 'Notepad' | 'Notification' | 'NotionLogo' | 'NuclearPlant' | 'NumberCircleEight' | 'NumberCircleFive' | 'NumberCircleFour' | 'NumberCircleNine' | 'NumberCircleOne' | 'NumberCircleSeven' | 'NumberCircleSix' | 'NumberCircleThree' | 'NumberCircleTwo' | 'NumberCircleZero' | 'NumberEight' | 'NumberFive' | 'NumberFour' | 'NumberNine' | 'NumberOne' | 'NumberSeven' | 'NumberSix' | 'NumberSquareEight' | 'NumberSquareFive' | 'NumberSquareFour' | 'NumberSquareNine' | 'NumberSquareOne' | 'NumberSquareSeven' | 'NumberSquareSix' | 'NumberSquareThree' | 'NumberSquareTwo' | 'NumberSquareZero' | 'NumberThree' | 'NumberTwo' | 'NumberZero' | 'Numpad' | 'Nut' | 'NyTimesLogo' | 'Octagon' | 'OfficeChair' | 'Onigiri' | 'OpenAiLogo' | 'Option' | 'Orange' | 'OrangeSlice' | 'Oven' | 'Package' | 'PaintBrush' | 'PaintBrushBroad' | 'PaintBrushHousehold' | 'PaintBucket' | 'PaintRoller' | 'Palette' | 'Panorama' | 'Pants' | 'PaperPlane' | 'PaperPlaneRight' | 'PaperPlaneTilt' | 'Paperclip' | 'PaperclipHorizontal' | 'Parachute' | 'Paragraph' | 'Parallelogram' | 'Park' | 'Password' | 'Path' | 'PatreonLogo' | 'Pause' | 'PauseCircle' | 'PawPrint' | 'PaypalLogo' | 'Peace' | 'Pen' | 'PenNib' | 'PenNibStraight' | 'Pencil' | 'PencilCircle' | 'PencilLine' | 'PencilRuler' | 'PencilSimple' | 'PencilSimpleLine' | 'PencilSimpleSlash' | 'PencilSlash' | 'Pentagon' | 'Pentagram' | 'Pepper' | 'Percent' | 'Person' | 'PersonArmsSpread' | 'PersonSimple' | 'PersonSimpleBike' | 'PersonSimpleCircle' | 'PersonSimpleHike' | 'PersonSimpleRun' | 'PersonSimpleSki' | 'PersonSimpleSnowboard' | 'PersonSimpleSwim' | 'PersonSimpleTaiChi' | 'PersonSimpleThrow' | 'PersonSimpleWalk' | 'Perspective' | 'Phone' | 'PhoneCall' | 'PhoneDisconnect' | 'PhoneIncoming' | 'PhoneList' | 'PhoneOutgoing' | 'PhonePause' | 'PhonePlus' | 'PhoneSlash' | 'PhoneTransfer' | 'PhoneX' | 'PhosphorLogo' | 'Pi' | 'PianoKeys' | 'PicnicTable' | 'PictureInPicture' | 'PiggyBank' | 'Pill' | 'PingPong' | 'PintGlass' | 'PinterestLogo' | 'Pinwheel' | 'Pipe' | 'PipeWrench' | 'PixLogo' | 'Pizza' | 'Placeholder' | 'Planet' | 'Plant' | 'Play' | 'PlayCircle' | 'PlayPause' | 'Playlist' | 'Plug' | 'PlugCharging' | 'Plugs' | 'PlugsConnected' | 'Plus' | 'PlusCircle' | 'PlusMinus' | 'PlusSquare' | 'PokerChip' | 'PoliceCar' | 'Polygon' | 'Popcorn' | 'Popsicle' | 'PottedPlant' | 'Power' | 'Prescription' | 'Presentation' | 'PresentationChart' | 'Printer' | 'Prohibit' | 'ProhibitInset' | 'ProjectorScreen' | 'ProjectorScreenChart' | 'Pulse' | 'PushPin' | 'PushPinSimple' | 'PushPinSimpleSlash' | 'PushPinSlash' | 'PuzzlePiece' | 'QrCode' | 'Question' | 'QuestionMark' | 'Queue' | 'Quotes' | 'Rabbit' | 'Racquet' | 'Radical' | 'Radio' | 'RadioButton' | 'Radioactive' | 'Rainbow' | 'RainbowCloud' | 'Ranking' | 'ReadCvLogo' | 'Receipt' | 'ReceiptX' | 'Record' | 'Rectangle' | 'RectangleDashed' | 'Recycle' | 'RedditLogo' | 'Repeat' | 'RepeatOnce' | 'ReplitLogo' | 'Resize' | 'Rewind' | 'RewindCircle' | 'RoadHorizon' | 'Robot' | 'Rocket' | 'RocketLaunch' | 'Rows' | 'RowsPlusBottom' | 'RowsPlusTop' | 'Rss' | 'RssSimple' | 'Rug' | 'Ruler' | 'Sailboat' | 'Scales' | 'Scan' | 'ScanSmiley' | 'Scissors' | 'Scooter' | 'Screencast' | 'Screwdriver' | 'Scribble' | 'ScribbleLoop' | 'Scroll' | 'Seal' | 'SealCheck' | 'SealPercent' | 'SealQuestion' | 'SealWarning' | 'Seat' | 'Seatbelt' | 'SecurityCamera' | 'Selection' | 'SelectionAll' | 'SelectionBackground' | 'SelectionForeground' | 'SelectionInverse' | 'SelectionPlus' | 'SelectionSlash' | 'Shapes' | 'Share' | 'ShareFat' | 'ShareNetwork' | 'Shield' | 'ShieldCheck' | 'ShieldCheckered' | 'ShieldChevron' | 'ShieldPlus' | 'ShieldSlash' | 'ShieldStar' | 'ShieldWarning' | 'ShippingContainer' | 'ShirtFolded' | 'ShootingStar' | 'ShoppingBag' | 'ShoppingBagOpen' | 'ShoppingCart' | 'ShoppingCartSimple' | 'Shovel' | 'Shower' | 'Shrimp' | 'Shuffle' | 'ShuffleAngular' | 'ShuffleSimple' | 'Sidebar' | 'SidebarSimple' | 'Sigma' | 'SignIn' | 'SignOut' | 'Signature' | 'Signpost' | 'SimCard' | 'Siren' | 'SketchLogo' | 'SkipBack' | 'SkipBackCircle' | 'SkipForward' | 'SkipForwardCircle' | 'Skull' | 'SkypeLogo' | 'SlackLogo' | 'Sliders' | 'SlidersHorizontal' | 'Slideshow' | 'Smiley' | 'SmileyAngry' | 'SmileyBlank' | 'SmileyMeh' | 'SmileyMelting' | 'SmileyNervous' | 'SmileySad' | 'SmileySticker' | 'SmileyWink' | 'SmileyXEyes' | 'SnapchatLogo' | 'Sneaker' | 'SneakerMove' | 'Snowflake' | 'SoccerBall' | 'Sock' | 'SolarPanel' | 'SolarRoof' | 'SortAscending' | 'SortDescending' | 'SoundcloudLogo' | 'Spade' | 'Sparkle' | 'SpeakerHifi' | 'SpeakerHigh' | 'SpeakerLow' | 'SpeakerNone' | 'SpeakerSimpleHigh' | 'SpeakerSimpleLow' | 'SpeakerSimpleNone' | 'SpeakerSimpleSlash' | 'SpeakerSimpleX' | 'SpeakerSlash' | 'SpeakerX' | 'Speedometer' | 'Sphere' | 'Spinner' | 'SpinnerBall' | 'SpinnerGap' | 'Spiral' | 'SplitHorizontal' | 'SplitVertical' | 'SpotifyLogo' | 'SprayBottle' | 'Square' | 'SquareHalf' | 'SquareHalfBottom' | 'SquareLogo' | 'SquareSplitHorizontal' | 'SquareSplitVertical' | 'SquaresFour' | 'Stack' | 'StackMinus' | 'StackOverflowLogo' | 'StackPlus' | 'StackSimple' | 'Stairs' | 'Stamp' | 'StandardDefinition' | 'Star' | 'StarAndCrescent' | 'StarFour' | 'StarHalf' | 'StarOfDavid' | 'StatusActive' | 'StatusArchived' | 'StatusDisabled' | 'StatusDraft' | 'StatusTemplate' | 'SteamLogo' | 'SteeringWheel' | 'Steps' | 'Stethoscope' | 'Sticker' | 'Stool' | 'Stop' | 'StopCircle' | 'Storefront' | 'Strategy' | 'StripeLogo' | 'Student' | 'SubsetOf' | 'SubsetProperOf' | 'Subtitles' | 'SubtitlesSlash' | 'Subtract' | 'SubtractSquare' | 'Subway' | 'Suitcase' | 'SuitcaseRolling' | 'SuitcaseSimple' | 'Sun' | 'SunDim' | 'SunHorizon' | 'Sunglasses' | 'SupersetOf' | 'SupersetProperOf' | 'Swap' | 'Swatches' | 'SwimmingPool' | 'Sword' | 'Synagogue' | 'Syringe' | 'TShirt' | 'Table' | 'Tabs' | 'Tag' | 'TagChevron' | 'TagSimple' | 'Target' | 'Taxi' | 'TeaBag' | 'TelegramLogo' | 'Television' | 'TelevisionSimple' | 'TennisBall' | 'Tent' | 'Terminal' | 'TerminalWindow' | 'TestTube' | 'TextAUnderline' | 'TextAa' | 'TextAlignCenter' | 'TextAlignJustify' | 'TextAlignLeft' | 'TextAlignRight' | 'TextB' | 'TextColumns' | 'TextH' | 'TextHFive' | 'TextHFour' | 'TextHOne' | 'TextHSix' | 'TextHThree' | 'TextHTwo' | 'TextIndent' | 'TextItalic' | 'TextOutdent' | 'TextStrikethrough' | 'TextSubscript' | 'TextSuperscript' | 'TextT' | 'TextTSlash' | 'TextUnderline' | 'Textbox' | 'Thermometer' | 'ThermometerCold' | 'ThermometerHot' | 'ThermometerSimple' | 'ThreadsLogo' | 'ThreeD' | 'ThumbsDown' | 'ThumbsUp' | 'Ticket' | 'TidalLogo' | 'TiktokLogo' | 'Tilde' | 'Timer' | 'TipJar' | 'Tipi' | 'Tire' | 'ToggleLeft' | 'ToggleRight' | 'Toilet' | 'ToiletPaper' | 'Toolbox' | 'Tooth' | 'Tornado' | 'Tote' | 'ToteSimple' | 'Towel' | 'Tractor' | 'Trademark' | 'TrademarkRegistered' | 'TrafficCone' | 'TrafficSign' | 'TrafficSignal' | 'Train' | 'TrainRegional' | 'TrainSimple' | 'Tram' | 'Translate' | 'Trash' | 'TrashSimple' | 'Tray' | 'TrayArrowDown' | 'TrayArrowUp' | 'TreasureChest' | 'Tree' | 'TreeEvergreen' | 'TreePalm' | 'TreeStructure' | 'TreeStructureDown' | 'TreeView' | 'TrendDown' | 'TrendUp' | 'Triangle' | 'TriangleDashed' | 'Trolley' | 'TrolleySuitcase' | 'Trophy' | 'Truck' | 'TruckTrailer' | 'TumblrLogo' | 'TwitchLogo' | 'TwitterLogo' | 'Umbrella' | 'UmbrellaSimple' | 'Union' | 'Unite' | 'UniteSquare' | 'Upload' | 'UploadSimple' | 'Usb' | 'User' | 'UserCheck' | 'UserCircle' | 'UserCircleCheck' | 'UserCircleDashed' | 'UserCircleGear' | 'UserCircleMinus' | 'UserCirclePlus' | 'UserFocus' | 'UserGear' | 'UserList' | 'UserMinus' | 'UserPlus' | 'UserRectangle' | 'UserSound' | 'UserSquare' | 'UserSwitch' | 'Users' | 'UsersFour' | 'UsersThree' | 'Van' | 'Vault' | 'VectorThree' | 'VectorTwo' | 'Vibrate' | 'Video' | 'VideoCamera' | 'VideoCameraSlash' | 'VideoConference' | 'Vignette' | 'VinylRecord' | 'VirtualReality' | 'Virus' | 'Visor' | 'Voicemail' | 'Volleyball' | 'Wall' | 'Wallet' | 'Warehouse' | 'Warning' | 'WarningCircle' | 'WarningDiamond' | 'WarningOctagon' | 'WashingMachine' | 'Watch' | 'WaveSawtooth' | 'WaveSine' | 'WaveSquare' | 'WaveTriangle' | 'Waveform' | 'WaveformSlash' | 'Waves' | 'Webcam' | 'WebcamSlash' | 'WebhooksLogo' | 'WechatLogo' | 'WhatsappLogo' | 'Wheelchair' | 'WheelchairMotion' | 'WifiHigh' | 'WifiLow' | 'WifiMedium' | 'WifiNone' | 'WifiSlash' | 'WifiX' | 'Wind' | 'Windmill' | 'WindowsLogo' | 'Wine' | 'WorkflowBuilderLogo' | 'Wrench' | 'X' | 'XCircle' | 'XLogo' | 'XSquare' | 'Yarn' | 'YinYang' | 'YoutubeLogo';

/**
 * Connects a component to a JsonForms cell, for list/array cell rendering.
 * @category Forms
 */
export declare const withJsonFormsCellProps: (Component: ComponentType<JsonFormsCore.CellProps>, memoize?: boolean) => ComponentType<JsonFormsCore.OwnPropsOfCell>;

/**
 * Connects a component to a JsonForms control, injecting control props.
 * @category Forms
 */
export declare const withJsonFormsControlProps: (Component: ComponentType<JsonFormsCore.ControlProps>, memoize?: boolean) => ComponentType<JsonFormsCore.OwnPropsOfControl>;

/**
 * Connects a component to a JsonForms label element.
 * @category Forms
 */
export declare const withJsonFormsLabelProps: (Component: ComponentType<JsonFormsCore.LabelProps & JsonFormsCore.OwnPropsOfEnum>, memoize?: boolean) => ComponentType<JsonFormsCore.OwnPropsOfLabel>;

/**
 * Connects a component to a JsonForms layout, injecting child uischema elements.
 * @category Forms
 */
export declare const withJsonFormsLayoutProps: <T extends JsonFormsCore.LayoutProps>(Component: ComponentType<T>, memoize?: boolean) => ComponentType<T & JsonFormsCore.OwnPropsOfLayout>;

/**
 * Workflow Builder compound component. Mount `<WorkflowBuilder.Root>` at the
 * top of the editor subtree; compose with `.TopBar`, `.Palette`, `.Canvas`,
 * `.PropertiesPanel`, or `.DefaultLayout` as children (or omit children to
 * get the default floating-overlay layout).
 *
 * ```tsx
 * import { WorkflowBuilder } from '@workflowbuilder/sdk';
 *
 * <WorkflowBuilder.Root nodeTypes={myNodeTypes} />
 * ```
 *
 * @category Core
 */
export declare const WorkflowBuilder: Readonly<{
    Root: typeof WorkflowBuilderRoot;
    TopBar: typeof WorkflowBuilderTopBar;
    Palette: typeof WorkflowBuilderPalette;
    Canvas: MemoExoticComponent<(props: DiagramContainerProps) => JSX.Element>;
    PropertiesPanel: typeof WorkflowBuilderPropertiesPanel;
    DefaultLayout: typeof WorkflowBuilderDefaultLayout;
}>;

/**
 * Imperative action surface for a custom layout that omits
 * `<WorkflowBuilder.TopBar />`. Mirrors every command the built-in app bar
 * exposes (`save`, modal openers, read-only and theme toggles) and adds
 * programmatic layout-direction control, which the bar itself does not offer.
 *
 * Stable across renders while the active integration and the mounted
 * React Flow instance are stable (layout actions close over the fit-view
 * callback, which is keyed on that instance).
 *
 * @category Hooks
 */
export declare type WorkflowBuilderActions = {
    /** Persist the current diagram through the active integration strategy. */
    save: () => Promise<DidSaveStatus>;
    /** Open the built-in workflow settings modal. */
    openSettings: () => void;
    /** Open the import-diagram modal. */
    openImport: () => void;
    /** Open the export-diagram modal. */
    openExport: () => void;
    /** Flip read-only mode. */
    toggleReadOnly: () => void;
    /** Set read-only mode explicitly. */
    setReadOnly: (value: boolean) => void;
    /** Flip the editor theme between `'light'` and `'dark'`. */
    toggleDarkMode: () => void;
    /** Set the editor theme explicitly. */
    setTheme: (theme: Theme) => void;
    /**
     * Set the diagram layout direction (`'RIGHT'` ↔ `'DOWN'`). Idempotent:
     * setting the same direction twice is a no-op. Position reflow is only
     * offered on {@link toggleLayoutDirection}, where it is unambiguous.
     */
    setLayoutDirection: (direction: LayoutDirection) => void;
    /**
     * Flip the diagram layout direction. Pass `options.flipPositions` to also
     * reflow node coordinates and/or `options.fitView` to re-fit the view
     * afterwards.
     */
    toggleLayoutDirection: (options?: LayoutChangeOptions) => void;
};

/**
 * Public canvas component. Mount directly via `<DiagramContainer />` /
 * `<WorkflowBuilder.Canvas />` when assembling a custom layout, or decorate
 * the slot through
 * `registerComponentDecorator<DiagramContainerProps>('DiagramContainer', …)`.
 *
 * @category Components
 */
export declare const WorkflowBuilderCanvas: MemoExoticComponent<(props: DiagramContainerProps) => JSX.Element>;

/**
 * Default editor layout — floating overlay with top bar, left palette,
 * right properties panel, and a full-screen canvas underneath. Rendered
 * automatically by `<WorkflowBuilder.Root>` when no children are passed.
 *
 * Mount it explicitly when you need to mix it with custom overlays:
 *
 * ```tsx
 * <WorkflowBuilder.Root>
 *   <WorkflowBuilder.DefaultLayout />
 *   <MyToast />
 * </WorkflowBuilder.Root>
 * ```
 *
 * @category Components
 */
export declare function WorkflowBuilderDefaultLayout(): JSX.Element;

/**
 * xyflow `Edge` parameterised with the SDK's `EdgeData` (label + icon).
 *
 * @category Types
 */
export declare type WorkflowBuilderEdge = Edge<EdgeData>;

/**
 * Per-edge-type custom renderer registry. Keys are `edge.type` values; values
 * are React components that take ReactFlow's {@link EdgeProps} (typed for
 * {@link WorkflowBuilderEdge}) and replace the default edge renderer for
 * matching edges.
 *
 * Unlike node templates, edge templates need no adapter: the built-in edges
 * already take `EdgeProps` directly, so a consumer component drops straight
 * into ReactFlow's edge-type map with no wrapping.
 *
 * @category Components
 */
export declare type WorkflowBuilderEdgeTemplates = Record<string, ComponentType<EdgeProps<WorkflowBuilderEdge>>>;

/**
 * Persistence strategy for a `<WorkflowBuilder.Root>` instance. Exactly one
 * variant applies. `integration` is itself optional — omitting it picks the
 * `localStorage` default.
 *
 * @category Integration
 */
export declare type WorkflowBuilderIntegration = 
/** Default — save to browser localStorage under `'workflowBuilderDiagram'`. Selected when `integration` is omitted entirely or set to `{}`. */
    {
    strategy?: 'localStorage';
}
/** REST persistence — SDK issues `GET endpoints.load` and `POST endpoints.save` on every save event. */
| {
    strategy: 'api';
    endpoints: {
        load: string;
        save: string;
    };
}
/** Host-managed — SDK invokes `onDataSave` with the diagram payload on every save event; the host owns where it lands. */
| {
    strategy: 'props';
    onDataSave: OnSaveExternal;
};

/**
 * Decides whether a dragged connection is allowed. Return `false` to block the
 * drop (no edge created, no flicker). Fail-open: if an endpoint can't be
 * resolved to a node, the connection is allowed and this is not invoked.
 *
 * @category Core
 */
export declare type WorkflowBuilderIsValidConnection = (params: WorkflowBuilderIsValidConnectionParams) => boolean;

/**
 * Arguments for {@link WorkflowBuilderIsValidConnection}. Source / target nodes
 * are resolved from the connection's ids, so a rule can branch on node `data`.
 *
 * @category Core
 */
export declare type WorkflowBuilderIsValidConnectionParams = {
    /** The connection candidate (handle ids normalized to `null`). */
    connection: Connection;
    /** Node the connection is dragged from. */
    sourceNode: WorkflowBuilderNode;
    /** Node the connection is dragged to. */
    targetNode: WorkflowBuilderNode;
};

/**
 * JsonForms extensions registered with the editor: custom renderers, cell
 * renderers, and plugin translations.
 *
 * @category Plugins
 */
export declare type WorkflowBuilderJsonFormConfig = {
    renderers?: JsonFormsRendererExtension[];
    cells?: JsonFormsCellExtension[];
    translations?: PluginTranslationResource;
};

/**
 * App-bar logo accepted by `<WorkflowBuilder.Root>`: an image URL, per-theme
 * image URLs, or a custom element.
 *
 * @category Core
 */
export declare type WorkflowBuilderLogo = string | {
    light: string;
    dark: string;
} | ReactElement;

/**
 * xyflow `Node` parameterised with the SDK's {@link NodeData}. The
 * node-instance shape used everywhere the editor references a node
 * (store, handlers, listeners, save payload).
 *
 * @category Types
 */
export declare type WorkflowBuilderNode = Node_2<NodeData>;

/**
 * Per-node-type custom template registry. Keys are `data.type` values from
 * the palette; values are React components that take
 * {@link WorkflowNodeTemplateProps} and replace the default node renderer
 * for matching nodes.
 *
 * @category Components
 */
export declare type WorkflowBuilderNodeTemplates = Record<string, ComponentType<WorkflowNodeTemplateProps>>;

declare type WorkflowBuilderOnSelectionChangeParams = {
    nodes: WorkflowBuilderNode[];
    edges: WorkflowBuilderEdge[];
};

/**
 * Left-side palette listing draggable node types and the template selector.
 * Mount via `<WorkflowBuilder.Palette />` (or the named
 * `<WorkflowBuilderPalette />` export) inside a custom layout; the default
 * layout already includes it.
 *
 * @category Components
 */
export declare function WorkflowBuilderPalette(): JSX.Element;

/**
 * Plugin initializer — a synchronous function invoked exactly once on the
 * first mount of `<WorkflowBuilder.Root>`. Inside the body call one of the
 * SDK's `register*` APIs:
 *
 * - `registerComponentDecorator` — inject UI / hooks into a known slot
 * - `registerFunctionDecorator` — intercept a registered function before/after
 * - `registerPluginTranslation` — add i18next strings under `plugins.<name>`
 * - `registerCustomRenderers` / `registerCustomCells` — extend JsonForms
 *
 * Plugins write into module-level registries; they do **not** see the per-Root
 * store. The Root invokes them through a `useRef`-guarded first-render hook,
 * so strict-mode double-render is a no-op and re-renders skip the work.
 *
 * @example
 * ```ts
 * const myPlugin: WorkflowBuilderPlugin = () => {
 *   registerComponentDecorator('OptionalAppBarTools', {
 *     content: MyButton,
 *     name: 'my-plugin',
 *   });
 * };
 * ```
 *
 * @category Plugins
 */
export declare type WorkflowBuilderPlugin = () => void;

/**
 * Right-side properties panel — renders the form for the currently selected
 * node or edge, plus its tabs (properties, variables). Mount via
 * `<WorkflowBuilder.PropertiesPanel />` (or the named
 * `<WorkflowBuilderPropertiesPanel />` export) inside a custom layout; the
 * default layout already includes it.
 *
 * @category Components
 */
export declare function WorkflowBuilderPropertiesPanel(): JSX.Element;

declare type WorkflowBuilderReactFlowInstance = ReactFlowInstance<WorkflowBuilderNode, WorkflowBuilderEdge>;

/**
 * Escape hatch for the underlying ReactFlow canvas: forwards any ReactFlow prop
 * except the ones the SDK owns ({@link SdkOwnedReactFlowKey}). Theme via the SDK
 * design tokens, not `colorMode`.
 *
 * Treat as static config: the canvas reads it out-of-band, so changing a value
 * at runtime may not apply until the canvas re-renders.
 *
 * @category Core
 */
export declare type WorkflowBuilderReactFlowProps = Omit<ReactFlowProps<WorkflowBuilderNode, WorkflowBuilderEdge>, AssertAssignable<SdkOwnedReactFlowKey, keyof ReactFlowProps<WorkflowBuilderNode, WorkflowBuilderEdge>>>;

/**
 * Top-level component that wires up the Workflow Builder editor. Provides
 * the per-instance store, integration wrapper, ReactFlow context, global
 * overlay (snackbar, loader, plugin hooks), and renders either the
 * supplied children or `<DefaultLayout />` as a fallback.
 *
 * @example Hello world
 * ```tsx
 * import { WorkflowBuilder } from '@workflowbuilder/sdk';
 *
 * export function App() {
 *   return <WorkflowBuilder.Root nodeTypes={myNodeTypes} />;
 * }
 * ```
 *
 * @example Custom layout
 * ```tsx
 * <WorkflowBuilder.Root nodeTypes={myNodeTypes}>
 *   <header><WorkflowBuilder.TopBar /></header>
 *   <aside><WorkflowBuilder.Palette /></aside>
 *   <main><WorkflowBuilder.Canvas /></main>
 *   <aside><WorkflowBuilder.PropertiesPanel /></aside>
 * </WorkflowBuilder.Root>
 * ```
 *
 * @category Core
 */
export declare function WorkflowBuilderRoot({ nodeTypes, nodeTemplates, edgeTemplates, diagramTemplates, plugins, jsonForm, integration, name, logo, logoHref, layoutDirection, initialNodes, initialEdges, isValidConnection, reactFlowProps, children, }: WorkflowBuilderRootProps): JSX.Element;

/**
 * Props accepted by `<WorkflowBuilder.Root>`.
 *
 * @category Core
 */
export declare type WorkflowBuilderRootProps = PropsWithChildren<{
    /**
     * Node type definitions rendered in the palette and used for validation.
     * **Must be a stable reference** — declare at module level or memoize.
     * Passing an inline literal (`nodeTypes={[...]}`) overwrites the SDK's
     * module-level palette holder on every parent re-render.
     */
    nodeTypes?: PaletteItemOrGroup[];
    /**
     * Per-node-type custom renderers — map of `data.type` → React component.
     * Overrides the default `WorkflowNodeTemplate` for the matching node type.
     * Use {@link defineNodeTemplate} for the typing helper.
     *
     * **Must be a stable reference** (same rationale as `nodeTypes`).
     */
    nodeTemplates?: WorkflowBuilderNodeTemplates;
    /**
     * Per-edge-type custom renderers. Map of `edge.type` to a React component.
     * Overrides the built-in `'labelEdge'` for the matching edge type; edges
     * whose type isn't registered fall back to the default edge.
     *
     * Each component is authored exactly like a ReactFlow custom edge (it takes
     * `EdgeProps` directly). The only SDK-specific step is registering it here
     * instead of via ReactFlow's `edgeTypes`. See ReactFlow's "Custom Edges"
     * guide: https://reactflow.dev/learn/customization/custom-edges. To match the
     * built-in selection and hover look, reuse the exported `useLabelEdgeHover`
     * and `EnhancedBaseEdge`, or restyle selection globally via the
     * `--ax-public-edge-color-select` CSS variable. A custom edge does not inherit
     * the built-in self-connecting loop or label rendering.
     *
     * **Must be a stable reference** (same rationale as `nodeTemplates`).
     */
    edgeTemplates?: WorkflowBuilderEdgeTemplates;
    /**
     * Diagram templates available in the template selector.
     * **Must be a stable reference** (same rationale as `nodeTypes`).
     */
    diagramTemplates?: TemplateModel[];
    /** Plugin initializers invoked synchronously, in order, on first mount. */
    plugins?: WorkflowBuilderPlugin[];
    /** Custom JsonForms renderers / cells / translations. */
    jsonForm?: WorkflowBuilderJsonFormConfig;
    /** Persistence strategy. Defaults to `{ strategy: 'localStorage' }`. */
    integration?: WorkflowBuilderIntegration;
    /** Workflow name displayed in the app bar and persisted with the diagram. */
    name?: string;
    /**
     * Replaces the built-in Workflow Builder logo in the app bar: an image URL,
     * `{ light, dark }` per-theme image URLs, or a custom element rendered as-is.
     */
    logo?: WorkflowBuilderLogo;
    /** Wraps the app-bar logo (built-in or custom) in a link opened in a new tab. */
    logoHref?: string;
    /** Initial layout direction (`'RIGHT'` or `'DOWN'`). */
    layoutDirection?: LayoutDirection;
    /** Initial nodes rendered on first mount. */
    initialNodes?: WorkflowBuilderNode[];
    /** Initial edges rendered on first mount. */
    initialEdges?: WorkflowBuilderEdge[];
    /**
     * Validate connections as the user draws them. Return `false` to reject the
     * drop. **Must be a stable reference.**
     *
     * @example
     * ```ts
     * const isValidConnection: WorkflowBuilderIsValidConnection = ({ sourceNode, targetNode }) =>
     *   !(sourceNode.data.type === 'start' && targetNode.data.type === 'start');
     * ```
     */
    isValidConnection?: WorkflowBuilderIsValidConnection;
    /**
     * Advanced escape hatch: forwards extra props to the ReactFlow canvas (see
     * {@link WorkflowBuilderReactFlowProps}). Treat as static config; runtime value
     * changes may not apply immediately.
     */
    reactFlowProps?: WorkflowBuilderReactFlowProps;
}>;

/**
 * Top bar with toolbar, project selector, and integration controls. Mount
 * via `<WorkflowBuilder.TopBar />` (or the named `<WorkflowBuilderTopBar />`
 * export) inside a custom layout; the default layout already includes it.
 *
 * @category Components
 */
export declare function WorkflowBuilderTopBar(): JSX.Element;

declare type WorkflowEditorState = DiagramState & PaletteState & DiagramSelectionState & DiagramDataModificationState & UserPreferencesState;

/**
 * Props for the editor's default workflow-node template. A custom node
 * type wraps this template (or composes its parts) to render its body —
 * see [Add a custom node](/docs/guides/add-a-custom-node/) for the
 * full pattern.
 *
 * `id`, `icon`, `label`, `description` define the header. `selected` /
 * `isValid` drive visual state. `showHandles` toggles the connection
 * dots; `layoutDirection` controls which sides those dots sit on.
 * `children` are rendered inside a collapsible body section.
 *
 * Generic over `P` so consumer templates can narrow `data.properties` to
 * their schema's shape without casts:
 *
 * ```ts
 * type MyProps = WorkflowNodeTemplateProps<NodeDataProperties<MySchema>>;
 * ```
 *
 * Defaults to the wide `BaseNodeProperties & Record<string, unknown>` so
 * existing usages remain backward-compatible.
 *
 * @category Components
 */
export declare type WorkflowNodeTemplateProps<P = BaseNodeProperties & Record<string, unknown>> = {
    id: string;
    icon: IconType;
    label: string;
    description: string;
    data?: NodeData<P>;
    selected?: boolean;
    layoutDirection?: LayoutDirection;
    isConnecting?: boolean;
    showHandles?: boolean;
    isValid?: boolean;
    children?: React.ReactNode;
};

export { }