@reopt-ai/opt-ui-primitives 1.4.2

package/dist/index.d.ts

@@ -0,0 +1,1186 @@
+import * as react from 'react';
+import react__default, { CSSProperties, ComponentPropsWithoutRef, ReactNode, ReactElement } from 'react';
+import * as _floating_ui_core from '@floating-ui/core';
+import * as _floating_ui_react from '@floating-ui/react';
+import { MiddlewareState, Placement, Strategy, OpenChangeReason } from '@floating-ui/react';
+import * as _floating_ui_react_dom from '@floating-ui/react-dom';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Manages controlled/uncontrolled state for input components.
+ * When `controlledValue` is provided, acts as controlled; otherwise uses internal state.
+ */
+declare function useControllableState<T>(defaultValue: T, controlledValue: T | undefined, onChange: ((value: T) => void) | undefined): [T, (value: T) => void];
+
+type AnimationState = "idle" | "entering" | "entered" | "leaving";
+/**
+ * Manages data-enter/data-leave animation attributes.
+ *
+ * The leave phase waits on the Web Animations API — `element.getAnimations()`
+ * (element-scoped, NOT the subtree) — so unmount happens exactly when the
+ * element's own CSS transition/animation settles. This replaces the previous
+ * animationend/transitionend listener approach, which had two defects:
+ *   1. a hardcoded 300ms fallback that unmounted BEFORE any longer animation,
+ *   2. listeners on the root element that also fired on a DESCENDANT's
+ *      transitionend (bubbling), unmounting the panel prematurely.
+ * Because `getAnimations()` reports only the element's own animations, a child
+ * finishing its transition can no longer end the parent early.
+ *
+ * Flow:
+ *   open=true  → mount → rAF → data-enter (triggers CSS transition/animation)
+ *   open=false → data-leave → await own getAnimations().finished → unmount
+ *
+ * Environments without the Web Animations API (e.g. jsdom) unmount on the next
+ * animation frame — the data-leave frame still paints, with no magic timeout.
+ */
+declare function useEnterLeave(open: boolean, options?: {
+    animated?: boolean;
+}): {
+    ref: react.RefObject<HTMLElement | null>;
+    mounted: boolean;
+    dataAttributes: Record<string, string>;
+    state: AnimationState;
+};
+
+/** Returns `focusVisibleProps` to spread on a focusable element. */
+declare function useFocusVisible(): {
+    focusVisibleProps: {
+        onFocus: (e: React.FocusEvent) => void;
+        onBlur: (e: React.FocusEvent) => void;
+    };
+};
+
+/** Options for `RovingTabindex`. */
+interface RovingTabindexOptions {
+    orientation?: "horizontal" | "vertical" | "both";
+    loop?: boolean;
+    rtl?: boolean;
+    /**
+     * Grid mode: the number of columns the items are laid out in. When set,
+     * ArrowUp/ArrowDown move by a whole row (±columns) and ArrowLeft/ArrowRight
+     * by one cell, regardless of `orientation` (WAI-ARIA grid pattern).
+     */
+    columns?: number;
+}
+/**
+ * Implements roving tabindex pattern for keyboard navigation.
+ *
+ * Only the active item has tabindex="0", all others have tabindex="-1".
+ * Arrow keys move focus between items. Sets data-active-item on the focused element.
+ *
+ * Compatible with the legacy Composite data-active-item styling contract.
+ */
+declare function useRovingTabindex(options?: RovingTabindexOptions): {
+    containerRef: react.RefObject<HTMLElement | null>;
+    containerProps: {
+        ref: react.RefObject<HTMLElement | null>;
+        onKeyDown: (e: React.KeyboardEvent) => void;
+    };
+    activeId: string | null;
+    register: (id: string, element: HTMLElement, disabled?: boolean) => void;
+    unregister: (id: string) => void;
+    moveTo: (id: string) => void;
+    getTabIndex: (id: string) => 0 | -1;
+};
+
+/** Why an overlay's open state changed, forwarded to `onOpenChange`. */
+type DismissReason = "escape-key" | "outside-press" | "ancestor-scroll";
+/** Dismissal behavior. `true` enables outside-press + escape-key. */
+type DismissConfig = boolean | {
+    outsidePress?: boolean;
+    escapeKey?: boolean;
+    ancestorScroll?: boolean;
+};
+/** Physical side a popup is placed on, derived from the resolved placement. */
+type Side = "top" | "right" | "bottom" | "left";
+/** Alignment of a popup along its side. */
+type Align = "start" | "center" | "end";
+/** Arguments passed to a function-valued offset. */
+interface OffsetArgs {
+    rects: MiddlewareState["rects"];
+    placement: Placement;
+}
+/** A fixed pixel offset or one derived from the anchor/popup dimensions. */
+type OffsetValue = number | ((args: OffsetArgs) => number);
+/** Options for `useFloating`. */
+interface UseFloatingOptions {
+    placement?: Placement;
+    strategy?: Strategy;
+    /** @deprecated Use `sideOffset`. Distance from the anchor along the side axis. */
+    gutter?: number;
+    /** Distance from the anchor along the side (main) axis. Default 4. */
+    sideOffset?: OffsetValue;
+    /** Distance along the alignment (cross) axis. */
+    alignOffset?: OffsetValue;
+    sameWidth?: boolean;
+    flip?: boolean;
+    /**
+     * Once positioned, keep the flipped side sticky instead of flipping back as
+     * the popup content resizes (e.g. a combobox list shrinking per keystroke).
+     */
+    lazyFlip?: boolean;
+    shift?: number | boolean;
+    overflowPadding?: number;
+    open?: boolean;
+    /** Called when floating-ui requests a close (dismiss). */
+    onOpenChange?: (open: boolean, reason?: DismissReason) => void;
+    /**
+     * Delegate outside-press / escape-key dismissal to @floating-ui/react's
+     * `useDismiss` (shadow-DOM-safe, reference-aware) instead of hand-rolled
+     * document listeners. Off unless set. Requires `onOpenChange`.
+     */
+    dismiss?: DismissConfig;
+}
+/**
+ * Wraps @floating-ui/react with an API compatible with the legacy popover
+ * positioning layer. Maps options (sideOffset/alignOffset, sameWidth, flip,
+ * shift, lazyFlip) to Floating UI middleware and surfaces positioning state
+ * (side/align/isPositioned/anchorHidden) plus CSS custom properties — without
+ * imposing any visual styling.
+ */
+declare function useFloating(options?: UseFloatingOptions): {
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    floatingStyles: CSSProperties;
+    placement: Placement;
+    side: Side;
+    align: Align;
+    isPositioned: boolean;
+    anchorHidden: boolean;
+    context: {
+        x: number;
+        y: number;
+        placement: Placement;
+        strategy: Strategy;
+        middlewareData: _floating_ui_core.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: OpenChangeReason) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: React.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: () => {
+        ref: ((node: _floating_ui_react_dom.ReferenceType | null) => void) & ((node: _floating_ui_react.ReferenceType | null) => void);
+    };
+    getFloatingProps: () => {
+        ref: ((node: HTMLElement | null) => void) & ((node: HTMLElement | null) => void);
+        style: CSSProperties;
+    };
+    /**
+     * `data-open`/`data-closed`/`data-side`/`data-align`/`data-anchor-hidden`
+     * for the positioner. Additive — spread onto the panel alongside existing
+     * data attributes so Core can target open state, resolved side, and anchor
+     * visibility with CSS only.
+     */
+    getPositionerStateProps: (isOpen: boolean) => Record<string, string>;
+};
+
+/**
+ * Generates a stable unique ID for a component.
+ * Uses React's built-in useId() for SSR-safe ID generation.
+ */
+declare function useId(providedId?: string): string;
+
+/** Options for {@link useFocusableWhenDisabled}. */
+interface FocusableWhenDisabledOptions {
+    disabled?: boolean;
+    /**
+     * Keep the element focusable and announced while disabled (APG pattern):
+     * emit `aria-disabled` instead of the native `disabled` attribute so it stays
+     * in the tab order and accessibility tree. The consumer must still suppress
+     * activation (Enter/Space/click) while disabled.
+     */
+    focusableWhenDisabled?: boolean;
+    /** Whether the target is a native `<button>` (which takes `disabled`). */
+    isNativeButton?: boolean;
+    /** tabIndex to apply to a non-native element to keep it focusable. */
+    tabIndex?: number;
+}
+/** Attribute props to spread onto the focusable element. */
+interface FocusableWhenDisabledProps {
+    disabled?: boolean;
+    "aria-disabled"?: true;
+    tabIndex?: number;
+}
+/**
+ * Resolve the disabled/aria-disabled/tabIndex attributes for a control that may
+ * stay focusable while disabled.
+ *
+ * Native `disabled` removes an element from the tab order AND the accessibility
+ * tree — a screen-reader user tabbing through never learns the control exists.
+ * The APG "focusable disabled" pattern keeps it reachable via `aria-disabled`
+ * instead. This is opt-in (`focusableWhenDisabled`) so existing behavior — a
+ * plain native `disabled` — is unchanged by default.
+ */
+declare function useFocusableWhenDisabled({ disabled, focusableWhenDisabled, isNativeButton, tabIndex, }: FocusableWhenDisabledOptions): FocusableWhenDisabledProps;
+
+/**
+ * Virtual-focus widgets (Menu/Select/Combobox/Command) keep DOM focus on the
+ * input/container and point `aria-activedescendant` at the active option, so the
+ * browser does NOT auto-scroll the highlighted option into view. Call this with
+ * the active option's element id to scroll it into view on each move — keeping
+ * the highlight visible when arrowing past the scrollable viewport edge.
+ *
+ * `block: "nearest"` avoids scrolling when the option is already fully visible.
+ */
+declare function useScrollActiveDescendantIntoView(activeId: string | null | undefined): void;
+
+/** Props for `DisclosureRoot`. */
+interface DisclosureRootProps {
+    children: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use `onOpenChange`. */
+    setOpen?: (open: boolean) => void;
+    animated?: boolean;
+}
+/** Renders the `DisclosureRoot` component. */
+declare function DisclosureRoot({ children, open: controlledOpen, defaultOpen, onOpenChange, setOpen: setOpenDeprecated, animated, }: DisclosureRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `DisclosureTrigger`. */
+interface DisclosureTriggerProps extends ComponentPropsWithoutRef<"button"> {
+}
+/** Renders the `DisclosureTrigger` component. */
+declare function DisclosureTrigger({ onClick, ...props }: DisclosureTriggerProps): react_jsx_runtime.JSX.Element;
+/** Props for `DisclosureContent`. */
+interface DisclosureContentProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * When closed, keep the content in the DOM as `hidden="until-found"` (instead
+     * of unmounting) so browser find-in-page can reveal it. Chromium progressive
+     * enhancement; disables the enter/leave animation for this content. On reveal
+     * a `beforematch` event opens the disclosure so state stays consistent.
+     */
+    hiddenUntilFound?: boolean;
+}
+/** Renders the `DisclosureContent` component. */
+declare function DisclosureContent({ hiddenUntilFound, style, ...props }: DisclosureContentProps): react_jsx_runtime.JSX.Element | null;
+
+/** Props for `Button`. */
+interface ButtonProps extends ComponentPropsWithoutRef<"button"> {
+    /**
+     * Whether Enter activates the button. Set to `false` to suppress the native
+     * Enter→click (e.g. a non-submit button inside a form). Default: native.
+     */
+    clickOnEnter?: boolean;
+    /**
+     * Whether Space activates the button. Set to `false` to suppress the native
+     * Space→click. Default: native.
+     */
+    clickOnSpace?: boolean;
+    /**
+     * Keep the button focusable and announced while disabled (APG pattern):
+     * emits `aria-disabled` instead of the native `disabled` attribute and blocks
+     * activation. Default: false — a disabled button uses native `disabled`.
+     */
+    focusableWhenDisabled?: boolean;
+}
+/**
+ * Accessible button primitive.
+ * Native <button> with keyboard handling defaults.
+ * Zero-overhead button primitive for the current stack.
+ */
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Returns a function that closes the nearest dialog. Useful for custom dismiss
+ * affordances (e.g. swipe-to-dismiss) that aren't a `DialogDismiss` button.
+ */
+declare function useDialogClose(): () => void;
+/** Props for `DialogRoot`. */
+interface DialogRootProps {
+    children: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use `onOpenChange`. */
+    setOpen?: (open: boolean) => void;
+    animated?: boolean;
+}
+/** Renders the `DialogRoot` component. */
+declare function DialogRoot({ children, open: controlledOpen, defaultOpen, onOpenChange, setOpen: setOpenDeprecated, animated, }: DialogRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `DialogDisclosure`. */
+interface DialogDisclosureProps extends ComponentPropsWithoutRef<"button"> {
+}
+declare const DialogDisclosure: react.ForwardRefExoticComponent<DialogDisclosureProps & react.RefAttributes<HTMLButtonElement>>;
+/** Props for `DialogPanel`. */
+interface DialogPanelProps extends Omit<ComponentPropsWithoutRef<"dialog">, "open"> {
+    backdrop?: ReactNode;
+    /** Close when the backdrop (outside the panel) is pressed. Default true. */
+    dismissOnBackdrop?: boolean;
+    /** Close on the Escape key. Default true. Alert dialogs set this false. */
+    dismissOnEscape?: boolean;
+}
+declare const DialogPanel: react.ForwardRefExoticComponent<DialogPanelProps & react.RefAttributes<HTMLDialogElement>>;
+/** Props for `AlertDialogPanel`. */
+interface AlertDialogPanelProps extends Omit<DialogPanelProps, "role"> {
+}
+/**
+ * A dialog that demands an explicit choice: `role="alertdialog"` and no
+ * backdrop/Escape dismissal by default. Compose with the other Dialog parts
+ * (DialogRoot/Disclosure/Heading/Description/Dismiss).
+ */
+declare const AlertDialogPanel: react.ForwardRefExoticComponent<AlertDialogPanelProps & react.RefAttributes<HTMLDialogElement>>;
+/** Props for `DialogHeading`. */
+interface DialogHeadingProps extends ComponentPropsWithoutRef<"h2"> {
+}
+/** Renders the `DialogHeading` component. */
+declare function DialogHeading(props: DialogHeadingProps): react_jsx_runtime.JSX.Element;
+/** Props for `DialogDescription`. */
+interface DialogDescriptionProps extends ComponentPropsWithoutRef<"p"> {
+}
+/** Renders the `DialogDescription` component. */
+declare function DialogDescription(props: DialogDescriptionProps): react_jsx_runtime.JSX.Element;
+/** Props for `DialogDismiss`. */
+interface DialogDismissProps extends ComponentPropsWithoutRef<"button"> {
+}
+declare const DialogDismiss: react.ForwardRefExoticComponent<DialogDismissProps & react.RefAttributes<HTMLButtonElement>>;
+
+/** Props for `TabsRoot`. */
+interface TabsRootProps {
+    children: ReactNode;
+    selectedId?: string;
+    defaultSelectedId?: string;
+    /** Called when the selected tab changes. */
+    onSelectedIdChange?: (id: string) => void;
+    /** @deprecated Use `onSelectedIdChange`. */
+    setSelectedId?: (id: string) => void;
+    orientation?: "horizontal" | "vertical";
+}
+/** Renders the `TabsRoot` component. */
+declare function TabsRoot({ children, selectedId: controlledId, defaultSelectedId, onSelectedIdChange, setSelectedId: setSelectedIdDeprecated, orientation, }: TabsRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `TabList`. */
+interface TabListProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `TabList` component. */
+declare function TabList({ role, onKeyDown, ...props }: TabListProps): react_jsx_runtime.JSX.Element;
+/** Props for `Tab`. */
+interface TabProps extends Omit<ComponentPropsWithoutRef<"button">, "id"> {
+    id: string;
+    disabled?: boolean;
+}
+/** Renders the `Tab` component. */
+declare function Tab({ id, disabled, onClick, ...props }: TabProps): react_jsx_runtime.JSX.Element;
+/** Props for `TabPanel`. */
+interface TabPanelProps extends Omit<ComponentPropsWithoutRef<"div">, "id"> {
+    tabId: string;
+}
+/** Renders the `TabPanel` component. */
+declare function TabPanel({ tabId, ...props }: TabPanelProps): react_jsx_runtime.JSX.Element | null;
+
+interface RadioGroupContextValue {
+    name: string;
+    value: string;
+    setValue: (value: string) => void;
+    disabled: boolean;
+    orientation: "horizontal" | "vertical";
+}
+/** Returns the active `RadioGroupContext` value. */
+declare function useRadioGroupContext(): RadioGroupContextValue | null;
+/** Props for `RadioGroupRoot`. */
+interface RadioGroupRootProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    children: ReactNode;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    /** Called when the selected value changes. */
+    onValueChange?: (value: string) => void;
+    /** @deprecated Use `onValueChange`. */
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    orientation?: "horizontal" | "vertical";
+}
+/** Renders the `RadioGroupRoot` component. */
+declare function RadioGroupRoot({ children, name: providedName, value: controlledValue, defaultValue, onValueChange, onChange, disabled, orientation, ...props }: RadioGroupRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `Radio`. */
+interface RadioProps extends Omit<ComponentPropsWithoutRef<"input">, "onChange" | "type"> {
+    value: string;
+    disabled?: boolean;
+}
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+
+/** Where a portaled overlay mounts: an element, an element id, or body. */
+type PortalRoot = HTMLElement | string | null;
+
+/** Props for `TooltipProvider`. */
+interface TooltipProviderProps {
+    children: ReactNode;
+    timeout?: number;
+    showTimeout?: number;
+    hideTimeout?: number;
+    placement?: "top" | "bottom" | "left" | "right" | "top-start" | "top-end" | "bottom-start" | "bottom-end";
+    animated?: boolean;
+    /** Render the tooltip in a portal (escapes clipping). Default: false. */
+    portal?: boolean;
+    /** Portal mount target (element or element id). Defaults to document.body. */
+    portalRoot?: PortalRoot;
+}
+/** Renders the `TooltipProvider` component. */
+declare function TooltipProvider({ children, timeout, showTimeout, hideTimeout, placement, animated, portal, portalRoot, }: TooltipProviderProps): react_jsx_runtime.JSX.Element;
+/** Props for `TooltipAnchor`. */
+interface TooltipAnchorProps extends ComponentPropsWithoutRef<"div"> {
+    /** Render a custom element instead of a wrapper div. The element receives tooltip props. */
+    render?: react__default.ReactElement;
+}
+declare const TooltipAnchor: react__default.ForwardRefExoticComponent<TooltipAnchorProps & react__default.RefAttributes<HTMLDivElement>>;
+/** Props for `Tooltip`. */
+interface TooltipProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `Tooltip` component. */
+declare function Tooltip({ children, onMouseEnter, onMouseLeave, ...props }: TooltipProps): react_jsx_runtime.JSX.Element | null;
+
+/** Props for `PopoverRoot`. */
+interface PopoverRootProps {
+    children: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use `onOpenChange`. */
+    setOpen?: (open: boolean) => void;
+    placement?: "top" | "bottom" | "left" | "right" | "top-start" | "top-end" | "bottom-start" | "bottom-end";
+    /**
+     * Move focus into the panel on open and restore it to the trigger on close.
+     * Default: false — opt in, since many consumers manage focus themselves
+     * (e.g. a popover acting as a custom menu).
+     */
+    manageFocus?: boolean;
+    animated?: boolean;
+    /** Render the panel in a portal (escapes `overflow`/`transform` clipping).
+     * Default: false. */
+    portal?: boolean;
+    /** Portal mount target (element or element id). Defaults to document.body.
+     * Point this inside a themed subtree (e.g. opt-shell `[data-harness]`) to
+     * keep scoped design tokens applied. */
+    portalRoot?: PortalRoot;
+}
+/** Renders the `PopoverRoot` component. */
+declare function PopoverRoot({ children, open: controlledOpen, defaultOpen, onOpenChange, setOpen: setOpenDeprecated, placement, manageFocus, animated, portal, portalRoot, }: PopoverRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `PopoverTrigger`. */
+interface PopoverTriggerProps extends ComponentPropsWithoutRef<"button"> {
+}
+declare const PopoverTrigger: react.ForwardRefExoticComponent<PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+/** Props for `PopoverContent`. */
+interface PopoverContentProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `PopoverContent` component. */
+declare function PopoverContent({ children, ...props }: PopoverContentProps): react_jsx_runtime.JSX.Element | null;
+/** Props for `PopoverClose`. */
+interface PopoverCloseProps extends ComponentPropsWithoutRef<"button"> {
+}
+declare const PopoverClose: react.ForwardRefExoticComponent<PopoverCloseProps & react.RefAttributes<HTMLButtonElement>>;
+
+/** Props for `SelectRoot`. */
+interface SelectRootProps {
+    children: ReactNode;
+    /** Selected value(s). `string` in single mode, `string[]` when `multiple`. */
+    value?: string | string[];
+    defaultValue?: string | string[];
+    /** Called when the selected value changes. */
+    onValueChange?: (value: string | string[]) => void;
+    /** @deprecated Use `onValueChange`. */
+    setValue?: (value: string | string[]) => void;
+    /** Allow selecting more than one option. The value becomes a `string[]`. */
+    multiple?: boolean;
+    /** Form field name. Renders hidden input(s) so the value submits with a form. */
+    name?: string;
+    open?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use `onOpenChange`. */
+    setOpen?: (open: boolean) => void;
+    animated?: boolean;
+    /** Render the listbox in a portal (escapes clipping). Default: false. */
+    portal?: boolean;
+    /** Portal mount target (element or element id). Defaults to document.body. */
+    portalRoot?: PortalRoot;
+}
+/** Renders the `SelectRoot` component. */
+declare function SelectRoot({ children, value: controlledValue, defaultValue, onValueChange, setValue: setValueDeprecated, multiple, name, open: controlledOpen, onOpenChange, setOpen: setOpenDeprecated, animated, portal, portalRoot, }: SelectRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `SelectLabel`. */
+interface SelectLabelProps extends ComponentPropsWithoutRef<"label"> {
+}
+/** Renders the `SelectLabel` component. */
+declare function SelectLabel(props: SelectLabelProps): react_jsx_runtime.JSX.Element;
+/** Props for `SelectTrigger`. */
+interface SelectTriggerProps extends ComponentPropsWithoutRef<"button"> {
+}
+declare const SelectTrigger: react.ForwardRefExoticComponent<SelectTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+/** Props for `SelectPopover`. */
+interface SelectPopoverProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `SelectPopover` component. */
+declare function SelectPopover({ children, ...props }: SelectPopoverProps): react_jsx_runtime.JSX.Element | null;
+/** Props for `SelectItem`. */
+interface SelectItemProps extends ComponentPropsWithoutRef<"div"> {
+    value: string;
+    disabled?: boolean;
+}
+/** Renders the `SelectItem` component. */
+declare function SelectItem({ value: itemValue, disabled, onClick, children, ...props }: SelectItemProps): react_jsx_runtime.JSX.Element;
+
+/** Props for `ComboboxRoot`. */
+interface ComboboxRootProps {
+    children: ReactNode;
+    value?: string;
+    defaultValue?: string;
+    /** Called when the selected value changes. */
+    onValueChange?: (value: string) => void;
+    /** @deprecated Use `onValueChange`. */
+    setValue?: (value: string) => void;
+    open?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use `onOpenChange`. */
+    setOpen?: (open: boolean) => void;
+    animated?: boolean;
+    /** Render the listbox in a portal (escapes clipping). Default: false. */
+    portal?: boolean;
+    /** Portal mount target (element or element id). Defaults to document.body. */
+    portalRoot?: PortalRoot;
+}
+/** Renders the `ComboboxRoot` component. */
+declare function ComboboxRoot({ children, value: controlledValue, defaultValue, onValueChange, setValue: setValueDeprecated, open: controlledOpen, onOpenChange, setOpen: setOpenDeprecated, animated, portal, portalRoot, }: ComboboxRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `ComboboxInput`. */
+interface ComboboxInputProps extends Omit<ComponentPropsWithoutRef<"input">, "value" | "onChange"> {
+}
+declare const ComboboxInput: react.ForwardRefExoticComponent<ComboboxInputProps & react.RefAttributes<HTMLInputElement>>;
+/** Props for `ComboboxPopover`. */
+interface ComboboxPopoverProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `ComboboxPopover` component. */
+declare function ComboboxPopover({ children, ...props }: ComboboxPopoverProps): react_jsx_runtime.JSX.Element | null;
+/** Props for `ComboboxItem`. */
+interface ComboboxItemProps extends ComponentPropsWithoutRef<"div"> {
+    value: string;
+    disabled?: boolean;
+}
+/** Renders the `ComboboxItem` component. */
+declare function ComboboxItem({ value: itemValue, disabled, onClick, children, ...props }: ComboboxItemProps): react_jsx_runtime.JSX.Element;
+/** Props for `ComboboxGroup`. */
+interface ComboboxGroupProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `ComboboxGroup` component. */
+declare function ComboboxGroup({ children, ...props }: ComboboxGroupProps): react_jsx_runtime.JSX.Element;
+/** Props for `ComboboxGroupLabel`. */
+interface ComboboxGroupLabelProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `ComboboxGroupLabel` component. */
+declare function ComboboxGroupLabel(props: ComboboxGroupLabelProps): react_jsx_runtime.JSX.Element;
+
+/** Props for `CommandRoot`. */
+interface CommandRootProps extends ComponentPropsWithoutRef<"div"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Whether items auto-filter based on `search`. Default: true. */
+    shouldFilter?: boolean;
+    /** Custom filter function. Default: case-insensitive substring match. */
+    filter?: (value: string, search: string, keywords: string[]) => boolean;
+    /** Called on Escape in the input — e.g. dismiss a host dialog. */
+    onEscape?: () => void;
+}
+/** Renders the `CommandRoot` component. */
+declare function CommandRoot({ children, value: controlledValue, defaultValue, onValueChange, shouldFilter, filter, onEscape, ...props }: CommandRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `CommandInput`. */
+interface CommandInputProps extends Omit<ComponentPropsWithoutRef<"input">, "value" | "onChange"> {
+    /** Optional controlled value. Falls back to root search state. */
+    value?: string;
+    /** Notified on every keystroke (in addition to root search update). */
+    onValueChange?: (value: string) => void;
+}
+declare const CommandInput: react.ForwardRefExoticComponent<CommandInputProps & react.RefAttributes<HTMLInputElement>>;
+/** Props for `CommandList`. */
+interface CommandListProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `CommandList` component. */
+declare function CommandList({ children, ...props }: CommandListProps): react_jsx_runtime.JSX.Element;
+/** Props for `CommandEmpty`. */
+interface CommandEmptyProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `CommandEmpty` component. Hidden while any item is visible. */
+declare function CommandEmpty({ children, ...props }: CommandEmptyProps): react_jsx_runtime.JSX.Element | null;
+/** Props for `CommandGroup`. */
+interface CommandGroupProps extends ComponentPropsWithoutRef<"div"> {
+    /** Optional heading rendered as group label. */
+    heading?: ReactNode;
+}
+/** Renders the `CommandGroup` component. */
+declare function CommandGroup({ heading, children, ...props }: CommandGroupProps): react_jsx_runtime.JSX.Element;
+/** Props for `CommandSeparator`. */
+interface CommandSeparatorProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `CommandSeparator` component. */
+declare function CommandSeparator(props: CommandSeparatorProps): react_jsx_runtime.JSX.Element;
+/** Props for `CommandItem`. */
+interface CommandItemProps extends Omit<ComponentPropsWithoutRef<"div">, "onSelect"> {
+    /** Searchable value for this item. Falls back to the rendered label. */
+    value: string;
+    /** Additional terms to match the search input against. */
+    keywords?: string[];
+    disabled?: boolean;
+    /** Fired on click or Enter when this item is active. */
+    onSelect?: (value: string) => void;
+}
+declare const CommandItem: react.ForwardRefExoticComponent<CommandItemProps & react.RefAttributes<HTMLDivElement>>;
+/** Read live command state (search, active, value) inside descendants. */
+declare function useCommandState(): {
+    search: string;
+    value: string;
+    activeValue: string;
+    visibleValues: string[];
+};
+
+interface MenubarContextValue {
+    activeMenuId: string | null;
+    setActiveMenuId: (id: string | null) => void;
+}
+/** Returns the active `MenubarContext` value. */
+declare function useMenubarContext(): MenubarContextValue | null;
+/** Props for `MenubarRoot`. */
+interface MenubarRootProps {
+    children: ReactNode;
+}
+/** Renders the `MenubarRoot` component. */
+declare function MenubarRoot({ children }: MenubarRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `MenubarContainer`. */
+interface MenubarContainerProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `MenubarContainer` component. Arrow keys rove between triggers. */
+declare function MenubarContainer({ onKeyDown, ...props }: MenubarContainerProps): react_jsx_runtime.JSX.Element;
+/** Props for `MenuRoot`. */
+interface MenuRootProps {
+    children: ReactNode;
+    open?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use `onOpenChange`. */
+    setOpen?: (open: boolean) => void;
+    animated?: boolean;
+    /** Render the menu in a portal (escapes clipping). Default: false. */
+    portal?: boolean;
+    /** Portal mount target (element or element id). Defaults to document.body. */
+    portalRoot?: PortalRoot;
+}
+/** Renders the `MenuRoot` component. */
+declare function MenuRoot({ children, open: controlledOpen, onOpenChange, setOpen: setOpenDeprecated, animated, portal, portalRoot, }: MenuRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `MenuTrigger`. */
+interface MenuTriggerProps extends ComponentPropsWithoutRef<"button"> {
+}
+declare const MenuTrigger: react.ForwardRefExoticComponent<MenuTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+/** Props for `MenuPopover`. */
+interface MenuPopoverProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `MenuPopover` component. */
+declare function MenuPopover({ children, onKeyDown, ...props }: MenuPopoverProps): react_jsx_runtime.JSX.Element | null;
+/** Props for `MenuItem`. */
+interface MenuItemProps extends ComponentPropsWithoutRef<"div"> {
+    disabled?: boolean;
+    hideOnClick?: boolean;
+}
+/** Renders the `MenuItem` component. */
+declare function MenuItem({ disabled, hideOnClick, onClick, children, ...props }: MenuItemProps): react_jsx_runtime.JSX.Element;
+/** Props for `MenuItemCheckbox`. */
+interface MenuItemCheckboxProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    name?: string;
+    value?: string;
+}
+/** Renders the `MenuItemCheckbox` component. */
+declare function MenuItemCheckbox({ checked, onChange, disabled, onClick, children, ...props }: MenuItemCheckboxProps): react_jsx_runtime.JSX.Element;
+/** Props for `MenuItemRadio`. */
+interface MenuItemRadioProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    name?: string;
+    value?: string;
+}
+/** Renders the `MenuItemRadio` component. */
+declare function MenuItemRadio({ checked, onChange, disabled, onClick, children, ...props }: MenuItemRadioProps): react_jsx_runtime.JSX.Element;
+/** Props for `MenuSeparator`. */
+interface MenuSeparatorProps extends ComponentPropsWithoutRef<"hr"> {
+}
+/** Renders the `MenuSeparator` component. */
+declare function MenuSeparator(props: MenuSeparatorProps): react_jsx_runtime.JSX.Element;
+/** Props for `MenuButtonArrow`. */
+interface MenuButtonArrowProps extends ComponentPropsWithoutRef<"span"> {
+}
+/** Renders the `MenuButtonArrow` component. */
+declare function MenuButtonArrow(props: MenuButtonArrowProps): react_jsx_runtime.JSX.Element;
+
+/** Props for `ToolbarRoot`. */
+interface ToolbarRootProps {
+    children: ReactNode;
+    orientation?: "horizontal" | "vertical";
+}
+/** Renders the `ToolbarRoot` component. */
+declare function ToolbarRoot({ children, orientation, }: ToolbarRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `ToolbarContainer`. */
+interface ToolbarContainerProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `ToolbarContainer` component. */
+declare function ToolbarContainer({ onKeyDown, ...props }: ToolbarContainerProps): react_jsx_runtime.JSX.Element;
+/** Props for `ToolbarButton`. */
+interface ToolbarButtonProps extends ComponentPropsWithoutRef<"button"> {
+}
+/** Renders the `ToolbarButton` component. */
+declare function ToolbarButton({ disabled, onFocus, ...props }: ToolbarButtonProps): react_jsx_runtime.JSX.Element;
+/** Props for `ToolbarSeparator`. */
+interface ToolbarSeparatorProps extends ComponentPropsWithoutRef<"hr"> {
+}
+/** Renders the `ToolbarSeparator` component. */
+declare function ToolbarSeparator(props: ToolbarSeparatorProps): react_jsx_runtime.JSX.Element;
+
+/** Props for `CompositeProvider`. */
+interface CompositeProviderProps {
+    children: ReactNode;
+    focusLoop?: boolean;
+    focusWrap?: boolean;
+    orientation?: "horizontal" | "vertical" | "both";
+    activeId?: string | null;
+    /** Called when the active item changes. */
+    onActiveIdChange?: (id: string) => void;
+    /** @deprecated Use `onActiveIdChange`. */
+    setActiveId?: (id: string) => void;
+}
+/** Renders the `CompositeProvider` component. */
+declare function CompositeProvider({ children, focusLoop, focusWrap, orientation, activeId: controlledActiveId, onActiveIdChange, setActiveId: setActiveIdDeprecated, }: CompositeProviderProps): react_jsx_runtime.JSX.Element;
+/** Props for `Composite`. */
+interface CompositeProps extends ComponentPropsWithoutRef<"div"> {
+    render?: ReactElement;
+}
+/** Renders the `Composite` component. */
+declare function Composite({ onKeyDown, render, ...props }: CompositeProps): react_jsx_runtime.JSX.Element;
+/** Props for `CompositeRow`. */
+interface CompositeRowProps extends ComponentPropsWithoutRef<"div"> {
+    render?: ReactElement;
+}
+/** Renders the `CompositeRow` component. */
+declare function CompositeRow({ render, ...props }: CompositeRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `CompositeItem`. */
+interface CompositeItemProps extends ComponentPropsWithoutRef<"button"> {
+    id?: string;
+    row?: number;
+    col?: number;
+    disabled?: boolean;
+    render?: ReactElement;
+}
+/** Renders the `CompositeItem` component. */
+declare function CompositeItem({ id: providedId, row, col, disabled, render, onFocus, ...props }: CompositeItemProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the headless separator primitive. */
+interface SeparatorProps extends ComponentPropsWithoutRef<"div"> {
+    /** Visual/semantic axis of the separator. Defaults to `"horizontal"`. */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * When `true`, the separator is purely visual: it exposes no role to the
+     * accessibility tree (use when an adjacent label already conveys the break).
+     */
+    decorative?: boolean;
+}
+/**
+ * Headless separator: renders a `<div>` with the correct WAI-ARIA semantics
+ * (`role="separator"` + `aria-orientation`) unless `decorative`. Carries a
+ * `data-orientation` attribute so consumers can style each axis.
+ */
+declare const Separator: react.ForwardRefExoticComponent<SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Props for `ToggleGroup`. */
+interface ToggleGroupProps extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange"> {
+    /** Selected value(s). String for single mode, string[] for `toggleMultiple`. */
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    /** Allow more than one item pressed at once. */
+    toggleMultiple?: boolean;
+    orientation?: "horizontal" | "vertical";
+    disabled?: boolean;
+}
+/**
+ * Groups related `Toggle`s with roving-tabindex keyboard navigation and shared
+ * pressed-state selection (single by default, or multiple via `toggleMultiple`).
+ * Renders a `role="group"` element and provides selection context to children.
+ */
+declare function ToggleGroup({ value: controlledValue, defaultValue, onValueChange, toggleMultiple, orientation, disabled, onKeyDown, ...props }: ToggleGroupProps): react_jsx_runtime.JSX.Element;
+/** Props for `Toggle`. */
+interface ToggleProps extends Omit<ComponentPropsWithoutRef<"button">, "value" | "onChange"> {
+    /** Controlled pressed state (standalone use only). */
+    pressed?: boolean;
+    /** Initial pressed state when uncontrolled (standalone use only). */
+    defaultPressed?: boolean;
+    /** Pressed-state change callback (standalone use only). */
+    onPressedChange?: (pressed: boolean) => void;
+    /** Identifies this toggle inside a `ToggleGroup`. Required within a group. */
+    value?: string;
+}
+/**
+ * A two-state button (`aria-pressed`). Works standalone or, when rendered
+ * inside a `ToggleGroup`, derives its pressed state from the group selection
+ * and participates in roving-tabindex navigation.
+ */
+declare function Toggle({ pressed: pressedProp, defaultPressed, onPressedChange, value, disabled, onClick, onFocus, ...props }: ToggleProps): react_jsx_runtime.JSX.Element;
+
+/** Props for `Switch`. */
+interface SwitchProps extends Omit<ComponentPropsWithoutRef<"button">, "onChange" | "value" | "type" | "checked"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    /** Emit a hidden native checkbox so the switch participates in form submit. */
+    name?: string;
+    value?: string;
+    required?: boolean;
+}
+/**
+ * Toggle switch primitive (`role="switch"`). Controlled or uncontrolled, with
+ * an optional hidden native input for form submission. Exposes `data-state`
+ * (checked/unchecked) and `data-disabled` for Core to style — no visuals here.
+ */
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLButtonElement>>;
+
+/** Props for `Checkbox`. */
+interface CheckboxProps extends Omit<ComponentPropsWithoutRef<"button">, "onChange" | "value" | "type" | "checked"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    /** Tri-state "mixed" — announced as `aria-checked="mixed"`. */
+    indeterminate?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    /** Emit a hidden native checkbox so it participates in form submit. */
+    name?: string;
+    value?: string;
+    required?: boolean;
+}
+/**
+ * Checkbox primitive (`role="checkbox"`) supporting an indeterminate tri-state
+ * (`aria-checked="mixed"`). Controlled or uncontrolled, with an optional hidden
+ * native input for form submission. Exposes `data-state`
+ * (checked/unchecked/indeterminate) for Core to render the check/indicator.
+ */
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLButtonElement>>;
+
+/** Props for `Progress`. */
+interface ProgressProps extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    /** Current value; `null` (or omitted) renders an indeterminate progressbar. */
+    value?: number | null;
+    min?: number;
+    max?: number;
+    /** Override the localized `aria-valuetext`. */
+    getValueLabel?: (value: number, min: number, max: number) => string;
+    children?: React.ReactNode;
+}
+/**
+ * Progressbar primitive (`role="progressbar"`). Reports value/min/max and a
+ * localized `aria-valuetext`; omit `value` (or pass `null`) for the
+ * indeterminate state. Exposes `data-state`
+ * (indeterminate/loading/complete) — no visuals here.
+ */
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Props for `Meter`. */
+interface MeterProps extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    /** Current value within [min, max]. */
+    value: number;
+    min?: number;
+    max?: number;
+    /** Override the localized `aria-valuetext`. */
+    getValueLabel?: (value: number, min: number, max: number) => string;
+    children?: React.ReactNode;
+}
+/**
+ * Meter primitive (`role="meter"`) — a scalar measurement within a known range
+ * (e.g. disk usage, score), distinct from Progress (task completion). Reports
+ * value/min/max and a localized `aria-valuetext`; exposes `data-value`.
+ */
+declare const Meter: react.ForwardRefExoticComponent<MeterProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Props for `AccordionRoot`. */
+interface AccordionRootProps {
+    children: ReactNode;
+    /** `"single"` allows one open panel, `"multiple"` allows many. */
+    type?: "single" | "multiple";
+    /** Selected value(s). `string | null` for single, `string[]` for multiple. */
+    value?: string | string[] | null;
+    defaultValue?: string | string[] | null;
+    onValueChange?: (value: string | string[] | null) => void;
+    /** Single mode: allow closing the open panel (so none is open). */
+    collapsible?: boolean;
+    disabled?: boolean;
+    /** Animate content enter/leave (default `true`). */
+    animated?: boolean;
+}
+/** Renders the `AccordionRoot` component. */
+declare function AccordionRoot({ children, type, value: controlledValue, defaultValue, onValueChange, collapsible, disabled, animated, }: AccordionRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `AccordionItem`. */
+interface AccordionItemProps extends ComponentPropsWithoutRef<"div"> {
+    /** Unique value identifying this item within the accordion. */
+    value: string;
+    disabled?: boolean;
+}
+/** Renders the `AccordionItem` component. */
+declare function AccordionItem({ value, disabled, ...props }: AccordionItemProps): react_jsx_runtime.JSX.Element;
+/** Props for `AccordionTrigger`. */
+interface AccordionTriggerProps extends ComponentPropsWithoutRef<"button"> {
+}
+/** Renders the `AccordionTrigger` component. */
+declare function AccordionTrigger({ onClick, disabled, ...props }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+/** Props for `AccordionContent`. */
+interface AccordionContentProps extends ComponentPropsWithoutRef<"div"> {
+}
+/** Renders the `AccordionContent` component. */
+declare function AccordionContent({ style, ...props }: AccordionContentProps): react_jsx_runtime.JSX.Element | null;
+
+/** Field name → error message map. Keys can be dot-paths (e.g. "items.0"). */
+type FormErrors = Partial<Record<string, string>>;
+/** Controls when the `validate` callback is invoked. */
+type ValidateOn = "change" | "blur" | "submit";
+/** Configuration for {@link useFormStore}. */
+interface FormStoreOptions<V extends Record<string, unknown> = Record<string, unknown>> {
+    /** Initial field values. Also used by `reset()` and `isDirty()`. */
+    defaultValues: V;
+    /** Return an errors object keyed by field name. Invoked based on `validateOn`. */
+    validate?: (values: V) => FormErrors | void;
+    /** Called after successful validation on submit. Supports async (enables `isSubmitting`). */
+    onSubmit?: (values: V) => void | Promise<void>;
+    /** When to run `validate`. `"change"` (default) | `"blur"` | `"submit"` */
+    validateOn?: ValidateOn;
+}
+/** Reactive form store returned by {@link useFormStore}. Provides typed field access, validation, dirty tracking, and async submit. */
+interface FormStoreInstance<V extends Record<string, unknown> = Record<string, unknown>> {
+    /** Get current values snapshot */
+    getValues(): V;
+    /** Get a field value by key (type-safe when V is specific) */
+    getValue<K extends keyof V & string>(name: K): V[K];
+    /** Get a field value by dot-path */
+    getValue(name: string): unknown;
+    /** Set a field value (type-safe when V is specific) */
+    setValue<K extends keyof V & string>(name: K, value: V[K]): void;
+    /** Set a field value by dot-path */
+    setValue(name: string, value: unknown): void;
+    /** Get all current errors */
+    getErrors(): FormErrors;
+    /** Get validation error for a field */
+    getError(name: string): string | undefined;
+    /** Set validation error for a specific field */
+    setError(name: string, error: string | undefined): void;
+    /** Check if a field has been touched */
+    getFieldTouched(name: string): boolean;
+    /** Mark a field as touched */
+    setFieldTouched(name: string, touched: boolean): void;
+    /** Check if any field differs from default */
+    isDirty(): boolean;
+    /** Check if a specific field differs from default */
+    isFieldDirty(name: string): boolean;
+    /** Run validation and return errors */
+    validate(): FormErrors;
+    /** Reset entire form to default values */
+    reset(): void;
+    /** Reset a single field to its default value */
+    resetField(name: string): void;
+    /** Submit handler (supports async onSubmit) */
+    submit(e?: {
+        preventDefault?(): void;
+    }): void;
+    /**
+     * Register a control element for a field so `submit()` can move focus to the
+     * first invalid control (WCAG-critical error recovery). Returns an
+     * unregister function; registration order approximates DOM order.
+     */
+    registerControl(name: string, getElement: () => HTMLElement | null): () => void;
+    /** Whether an async submit is in progress */
+    isSubmitting(): boolean;
+    /** Error thrown by the last async onSubmit (cleared on next submit or reset) */
+    getSubmitError(): unknown;
+    /** Push item to array field */
+    push<K extends keyof V & string>(name: K, item: V[K] extends (infer U)[] ? U : unknown): void;
+    /** Push item to array field by dot-path */
+    push(name: string, item: unknown): void;
+    /** Remove item from array field by index */
+    remove(name: string, index: number): void;
+    /** Subscribe for re-renders */
+    subscribe(listener: () => void): () => void;
+    /** Get snapshot version for useSyncExternalStore */
+    getSnapshot(): number;
+}
+/**
+ * Creates and manages a form store with type-safe field access.
+ *
+ * The store is created once (via internal `useRef`) and the options are kept
+ * fresh via a ref so `validate`/`onSubmit` closures always see current props.
+ *
+ * @param options - Store configuration (defaultValues, validate, onSubmit, validateOn)
+ * @returns A `FormStoreInstance<V>` with typed getValue/setValue
+ *
+ * @example
+ * ```tsx
+ * const form = useFormStore({
+ *   defaultValues: { email: "", password: "" },
+ *   validate: (values) => {
+ *     const errors: FormErrors = {};
+ *     if (!values.email) errors.email = "Required";
+ *     return errors;
+ *   },
+ *   onSubmit: async (values) => { await api.save(values); },
+ * });
+ *
+ * form.getValue("email");     // type: string
+ * form.isDirty();             // true if any field changed
+ * form.isSubmitting();        // true during async submit
+ * form.getSubmitError();      // last async submit error or undefined
+ * ```
+ */
+declare function useFormStore<V extends Record<string, unknown>>(options: FormStoreOptions<V>): FormStoreInstance<V>;
+/**
+ * Subscribe to a single field value. Re-renders only when that field changes.
+ *
+ * @param store - The form store instance
+ * @param name  - Field name (supports dot-path, e.g. "items.0")
+ * @returns The current field value, cast to `T`
+ *
+ * @example
+ * ```tsx
+ * const email = useFieldValue<string>(form, "email");
+ * ```
+ */
+declare function useFieldValue<T = unknown>(store: FormStoreInstance, name: string): T;
+
+/**
+ * Provides form store to descendant form components.
+ * Form provider for the current typed FormStore stack.
+ */
+declare function FormProvider({ store, children, }: {
+    store: FormStoreInstance;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Access the form store from any descendant component.
+ * Typed form context hook for the current FormStore stack.
+ */
+declare function useFormContext(): FormStoreInstance | null;
+
+/** Props for `FormRoot`. */
+interface FormRootProps extends ComponentPropsWithoutRef<"form"> {
+}
+/** Renders the `FormRoot` component. */
+declare function FormRoot({ onSubmit, ...props }: FormRootProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormField`. */
+interface FormFieldProps extends ComponentPropsWithoutRef<"div"> {
+    /** Field name. When set, descendant label/control/error/description are
+     * automatically wired together (htmlFor/id/aria-describedby). */
+    name?: string;
+}
+/** Renders the `FormField` component. */
+declare function FormField({ name, ...props }: FormFieldProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormLabel`. */
+interface FormLabelProps extends ComponentPropsWithoutRef<"label"> {
+    /** @deprecated Field association is derived from the enclosing `FormField`. */
+    name?: string;
+}
+/** Renders the `FormLabel` component. */
+declare function FormLabel({ htmlFor, name: _name, ...props }: FormLabelProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormInput`. */
+interface FormInputProps extends Omit<ComponentPropsWithoutRef<"input">, "name"> {
+    name: string;
+}
+declare const FormInput: react.ForwardRefExoticComponent<FormInputProps & react.RefAttributes<HTMLInputElement>>;
+/** Props for `FormTextarea`. */
+interface FormTextareaProps extends Omit<ComponentPropsWithoutRef<"textarea">, "name"> {
+    name: string;
+}
+declare const FormTextarea: react.ForwardRefExoticComponent<FormTextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+/** Props for `FormSelect`. */
+interface FormSelectProps extends Omit<ComponentPropsWithoutRef<"select">, "name"> {
+    name: string;
+}
+declare const FormSelect: react.ForwardRefExoticComponent<FormSelectProps & react.RefAttributes<HTMLSelectElement>>;
+/** Props for `FormSwitch`. */
+interface FormSwitchProps extends Omit<ComponentPropsWithoutRef<"button">, "name" | "onChange" | "type"> {
+    name: string;
+}
+declare const FormSwitch: react.ForwardRefExoticComponent<FormSwitchProps & react.RefAttributes<HTMLButtonElement>>;
+/** Props for `FormCheckbox`. */
+interface FormCheckboxProps extends Omit<ComponentPropsWithoutRef<"input">, "name" | "type"> {
+    name: string;
+    value?: string;
+}
+declare const FormCheckbox: react.ForwardRefExoticComponent<FormCheckboxProps & react.RefAttributes<HTMLInputElement>>;
+/** Props for `FormRadioGroup`. */
+interface FormRadioGroupProps extends ComponentPropsWithoutRef<"div"> {
+    /** @deprecated Pass `name` to each `FormRadio` instead. */
+    name?: string;
+}
+/** Renders the `FormRadioGroup` component. */
+declare function FormRadioGroup({ name: _name, ...props }: FormRadioGroupProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormRadio`. */
+interface FormRadioProps extends Omit<ComponentPropsWithoutRef<"input">, "name" | "type"> {
+    name: string;
+    value: string;
+}
+declare const FormRadio: react.ForwardRefExoticComponent<FormRadioProps & react.RefAttributes<HTMLInputElement>>;
+/** Props for `FormDescription`. */
+interface FormDescriptionProps extends ComponentPropsWithoutRef<"p"> {
+    /** @deprecated Association is derived from the enclosing `FormField`. */
+    name?: string;
+}
+/** Renders the `FormDescription` component. */
+declare function FormDescription({ name: _name, ...props }: FormDescriptionProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormError`. */
+interface FormErrorProps extends ComponentPropsWithoutRef<"p"> {
+    name: string;
+}
+/** Renders the `FormError` component. */
+declare function FormError({ name, children, ...props }: FormErrorProps): react_jsx_runtime.JSX.Element | null;
+/** Props for `FormControl`. */
+type FormControlProps = FormInputProps;
+/** Alias of {@link FormInput}. */
+declare const FormControl: react.ForwardRefExoticComponent<FormInputProps & react.RefAttributes<HTMLInputElement>>;
+/** Props for `FormSubmit`. */
+interface FormSubmitProps extends ComponentPropsWithoutRef<"button"> {
+}
+/** Renders the `FormSubmit` component. Auto-disables during async submit. */
+declare function FormSubmit({ type, disabled, ...props }: FormSubmitProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormReset`. */
+interface FormResetProps extends ComponentPropsWithoutRef<"button"> {
+}
+/** Renders the `FormReset` component. */
+declare function FormReset({ onClick, ...props }: FormResetProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormPush`. */
+interface FormPushProps extends Omit<ComponentPropsWithoutRef<"button">, "value"> {
+    name: string;
+    value: unknown;
+}
+/** Renders the `FormPush` component. */
+declare function FormPush({ name, value, onClick, ...props }: FormPushProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormRemove`. */
+interface FormRemoveProps extends ComponentPropsWithoutRef<"button"> {
+    name: string;
+    index: number;
+}
+/** Renders the `FormRemove` component. */
+declare function FormRemove({ name, index, onClick, ...props }: FormRemoveProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormGroup`. */
+interface FormGroupProps extends ComponentPropsWithoutRef<"fieldset"> {
+}
+/** Renders the `FormGroup` component. */
+declare function FormGroup(props: FormGroupProps): react_jsx_runtime.JSX.Element;
+/** Props for `FormGroupLabel`. */
+interface FormGroupLabelProps extends ComponentPropsWithoutRef<"legend"> {
+}
+/** Renders the `FormGroupLabel` component. */
+declare function FormGroupLabel(props: FormGroupLabelProps): react_jsx_runtime.JSX.Element;
+
+export { AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, AccordionRoot, type AccordionRootProps, AccordionTrigger, type AccordionTriggerProps, AlertDialogPanel, type AlertDialogPanelProps, type Align, Button, type ButtonProps, Checkbox, type CheckboxProps, ComboboxGroup, ComboboxGroupLabel, type ComboboxGroupLabelProps, type ComboboxGroupProps, ComboboxInput, type ComboboxInputProps, ComboboxItem, type ComboboxItemProps, ComboboxPopover, type ComboboxPopoverProps, ComboboxRoot, type ComboboxRootProps, CommandEmpty, type CommandEmptyProps, CommandGroup, type CommandGroupProps, CommandInput, type CommandInputProps, CommandItem, type CommandItemProps, CommandList, type CommandListProps, CommandRoot, type CommandRootProps, CommandSeparator, type CommandSeparatorProps, Composite, CompositeItem, type CompositeItemProps, type CompositeProps, CompositeProvider, type CompositeProviderProps, CompositeRow, type CompositeRowProps, DialogDescription, type DialogDescriptionProps, DialogDisclosure, type DialogDisclosureProps, DialogDismiss, type DialogDismissProps, DialogHeading, type DialogHeadingProps, DialogPanel, type DialogPanelProps, DialogRoot, type DialogRootProps, DisclosureContent, type DisclosureContentProps, DisclosureRoot, type DisclosureRootProps, DisclosureTrigger, type DisclosureTriggerProps, type FocusableWhenDisabledOptions, type FocusableWhenDisabledProps, FormCheckbox, type FormCheckboxProps, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormError, type FormErrorProps, type FormErrors, FormField, type FormFieldProps, FormGroup, FormGroupLabel, type FormGroupLabelProps, type FormGroupProps, FormInput, type FormInputProps, FormLabel, type FormLabelProps, FormProvider, FormPush, type FormPushProps, FormRadio, FormRadioGroup, type FormRadioGroupProps, type FormRadioProps, FormRemove, type FormRemoveProps, FormReset, type FormResetProps, FormRoot, type FormRootProps, FormSelect, type FormSelectProps, type FormStoreInstance, type FormStoreOptions, FormSubmit, type FormSubmitProps, FormSwitch, type FormSwitchProps, FormTextarea, type FormTextareaProps, MenuButtonArrow, type MenuButtonArrowProps, MenuItem, MenuItemCheckbox, type MenuItemCheckboxProps, type MenuItemProps, MenuItemRadio, type MenuItemRadioProps, MenuPopover, type MenuPopoverProps, MenuRoot, type MenuRootProps, MenuSeparator, type MenuSeparatorProps, MenuTrigger, type MenuTriggerProps, MenubarContainer, type MenubarContainerProps, MenubarRoot, type MenubarRootProps, Meter, type MeterProps, type OffsetArgs, type OffsetValue, PopoverClose, type PopoverCloseProps, PopoverContent, type PopoverContentProps, PopoverRoot, type PopoverRootProps, PopoverTrigger, type PopoverTriggerProps, Progress, type ProgressProps, Radio, RadioGroupRoot, type RadioGroupRootProps, type RadioProps, type RovingTabindexOptions, SelectItem, type SelectItemProps, SelectLabel, type SelectLabelProps, SelectPopover, type SelectPopoverProps, SelectRoot, type SelectRootProps, SelectTrigger, type SelectTriggerProps, Separator, type SeparatorProps, type Side, Switch, type SwitchProps, Tab, TabList, type TabListProps, TabPanel, type TabPanelProps, type TabProps, TabsRoot, type TabsRootProps, Toggle, ToggleGroup, type ToggleGroupProps, type ToggleProps, ToolbarButton, type ToolbarButtonProps, ToolbarContainer, type ToolbarContainerProps, ToolbarRoot, type ToolbarRootProps, ToolbarSeparator, type ToolbarSeparatorProps, Tooltip, TooltipAnchor, type TooltipAnchorProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, type UseFloatingOptions, type ValidateOn, useCommandState, useControllableState, useDialogClose, useEnterLeave, useFieldValue, useFloating, useFocusVisible, useFocusableWhenDisabled, useFormContext, useFormStore, useId, useMenubarContext, useRadioGroupContext, useRovingTabindex, useScrollActiveDescendantIntoView };