@compa11y/react 0.1.8 → 0.1.11

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import * as React$1 from 'react';
-import React__default, { ReactNode, InputHTMLAttributes, ButtonHTMLAttributes, TextareaHTMLAttributes } from 'react';
+import React__default, { ReactNode, InputHTMLAttributes, ButtonHTMLAttributes, TextareaHTMLAttributes, RefObject } from 'react';
 import { FocusTrapOptions, AnnouncerOptions, KeyboardHandlers, FocusNeighborOptions, FocusReturnOptions } from '@compa11y/core';
 export { announce, announceAssertive, announceError, announcePolite, announceProgress, announceStatus, aria, buildAriaProps, checks, createComponentWarnings, hasAccessibleName, isAndroid, isBrowser, isIOS, isMac, mergeAriaIds, prefersDarkMode, prefersHighContrast, prefersReducedMotion, setWarningHandler, warn } from '@compa11y/core';
 export { DialogCompound as Dialog, DialogActions, DialogActionsProps, Dialog as DialogBase, DialogClose, DialogCloseProps, DialogContent, DialogContentProps, DialogContextValue, DialogDescription, DialogDescriptionProps, DialogProps, DialogTitle, DialogTitleProps, DialogTrigger, DialogTriggerProps, useDialogContext } from './components/dialog/index.cjs';
@@ -428,6 +428,8 @@ interface SelectProps {
 }
 declare function Select({ options, value: controlledValue, defaultValue, onValueChange, disabled, placeholder, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, children, }: SelectProps): react_jsx_runtime.JSX.Element;
 interface SelectTriggerProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
+    /** Placeholder text shown when no value is selected (overrides the root Select placeholder) */
+    placeholder?: string;
 }
 declare const SelectTrigger: React__default.ForwardRefExoticComponent<SelectTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
 interface SelectListboxProps extends React__default.HTMLAttributes<HTMLUListElement> {
@@ -1281,4 +1283,679 @@ interface AlertProps extends React__default.HTMLAttributes<HTMLDivElement> {
 }
 declare const Alert: React__default.ForwardRefExoticComponent<AlertProps & React__default.RefAttributes<HTMLDivElement>>;
 
-export { Alert, type AlertProps, type AlertType, Button, type ButtonProps, CheckboxCompound as Checkbox, Checkbox as CheckboxBase, CheckboxGroup, type CheckboxGroupContextValue, type CheckboxGroupProps, CheckboxIndicator, type CheckboxIndicatorProps, type CheckboxProps, InputCompound as Input, Input as InputBase, type InputContextValue, InputError, type InputErrorProps, InputField, type InputFieldProps, InputHint, type InputHintProps, InputLabel, type InputLabelProps, type InputProps, ListboxCompound as Listbox, Listbox as ListboxBase, type ListboxContextValue, ListboxGroup, type ListboxGroupProps, ListboxOption, type ListboxOptionProps, type ListboxProps, Radio, RadioGroupCompound as RadioGroup, RadioGroup as RadioGroupBase, type RadioGroupContextValue, type RadioGroupProps, type RadioProps, type RovingTabindexItem, SelectCompound as Select, Select as SelectBase, SelectListbox, type SelectListboxProps, SelectOptionItem, type SelectOptionProps, type SelectOption as SelectOptionType, type SelectProps, SelectTrigger, type SelectTriggerProps, SkipLink, type SkipLinkProps, Switch, type SwitchProps, TextareaCompound as Textarea, Textarea as TextareaBase, type TextareaContextValue, TextareaError, type TextareaErrorProps, TextareaField, type TextareaFieldProps, TextareaHint, type TextareaHintProps, TextareaLabel, type TextareaLabelProps, type TextareaProps, type UseFocusTrapOptions, type UseRovingTabindexOptions, VisuallyHidden, type VisuallyHiddenProps, useAnnounceLoading, useAnnounceOnChange, useAnnouncer, useCheckboxGroupContext, useFocusControl, useFocusManager, useFocusNeighbor, useFocusReturn, useFocusTrap, useFocusTrapControls, useFocusVisible, useFocusWithin, useGridKeyboard, useId, useIdScope, useIds, useInputContext, useKeyPressed, useKeyboard, useListboxContext, useMenuKeyboard, useRadioGroupContext, useRovingTabindex, useRovingTabindexMap, useTabsKeyboard, useTextareaContext, useTypeAhead };
+/**
+ * Accessible Link component.
+ *
+ * An enhanced anchor element that handles external link indicators,
+ * `aria-current` for navigation, and proper focus styling.
+ *
+ * @example
+ * ```tsx
+ * // Basic link
+ * <Link href="/about">About us</Link>
+ *
+ * // External link (opens in new tab with screen reader hint)
+ * <Link href="https://example.com" external>Visit Example</Link>
+ *
+ * // Current page in navigation
+ * <Link href="/dashboard" current="page">Dashboard</Link>
+ *
+ * // Disabled link
+ * <Link href="/settings" disabled>Settings</Link>
+ * ```
+ *
+ * Keyboard: Tab to focus, Enter to activate.
+ */
+
+interface LinkProps extends Omit<React__default.AnchorHTMLAttributes<HTMLAnchorElement>, 'aria-current'> {
+    /** Opens in new tab with rel="noopener noreferrer" and screen reader hint */
+    external?: boolean;
+    /** Sets aria-current for navigation context */
+    current?: 'page' | 'step' | 'location' | 'true' | boolean;
+    /** Disables the link (removes from tab order, prevents navigation) */
+    disabled?: boolean;
+    /** Remove default styles */
+    unstyled?: boolean;
+}
+declare const Link: React__default.ForwardRefExoticComponent<LinkProps & React__default.RefAttributes<HTMLAnchorElement>>;
+
+/**
+ * Accessible Text and Heading components.
+ *
+ * Typography primitives that render semantic HTML elements.
+ *
+ * @example
+ * ```tsx
+ * // Heading
+ * <Heading level={1}>Page Title</Heading>
+ * <Heading level={2} size="lg">Smaller h2</Heading>
+ *
+ * // Text
+ * <Text>Body paragraph.</Text>
+ * <Text size="sm" color="muted">Small muted text.</Text>
+ * <Text as="span">Inline text.</Text>
+ * <Text truncate>Long text that gets cut off...</Text>
+ * ```
+ */
+
+type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+type TextColor = 'default' | 'muted' | 'accent' | 'error' | 'success' | 'warning';
+type TextWeight = 'normal' | 'medium' | 'semibold' | 'bold';
+type TextAlign = 'left' | 'center' | 'right';
+interface HeadingProps extends React__default.HTMLAttributes<HTMLHeadingElement> {
+    /** Heading level 1–6 */
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Override the default size for this heading level */
+    size?: TextSize;
+    /** Text color variant */
+    color?: TextColor;
+    /** Font weight override */
+    weight?: TextWeight;
+    /** Text alignment */
+    align?: TextAlign;
+    /** Truncate with ellipsis */
+    truncate?: boolean;
+    /** Remove default styles */
+    unstyled?: boolean;
+}
+declare const Heading: React__default.ForwardRefExoticComponent<HeadingProps & React__default.RefAttributes<HTMLHeadingElement>>;
+type TextElement = 'p' | 'span' | 'div' | 'label';
+interface TextProps extends React__default.HTMLAttributes<HTMLElement> {
+    /** HTML element to render */
+    as?: TextElement;
+    /** Text size */
+    size?: TextSize;
+    /** Text color variant */
+    color?: TextColor;
+    /** Font weight */
+    weight?: TextWeight;
+    /** Text alignment */
+    align?: TextAlign;
+    /** Truncate with ellipsis */
+    truncate?: boolean;
+    /** Remove default styles */
+    unstyled?: boolean;
+}
+declare const Text: React__default.ForwardRefExoticComponent<TextProps & React__default.RefAttributes<HTMLElement>>;
+
+type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+/**
+ * 'first'     — focus first focusable child (default, good for interactive popovers)
+ * 'container' — focus the content container itself (tabindex=-1)
+ * 'none'      — do not move focus (good for pointer-triggered informational popovers)
+ */
+type PopoverFocusPolicy = 'first' | 'container' | 'none';
+interface PopoverProps {
+    /** Whether the popover is open (controlled) */
+    open?: boolean;
+    /** Default open state (uncontrolled) */
+    defaultOpen?: boolean;
+    /** Called when open state should change */
+    onOpenChange?: (open: boolean) => void;
+    /** Disable the trigger, preventing the popover from opening */
+    disabled?: boolean;
+    children: React__default.ReactNode;
+}
+interface PopoverTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * aria-haspopup value applied to the trigger button.
+     * Should match the role of the popover content.
+     * @default 'dialog'
+     */
+    haspopup?: 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid' | 'true' | false;
+}
+interface PopoverContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Preferred placement. Auto-flips if the popover would overflow the viewport.
+     * @default 'bottom'
+     */
+    placement?: PopoverPlacement;
+    /**
+     * Pixel gap between trigger and popover.
+     * @default 8
+     */
+    offset?: number;
+    /**
+     * ARIA role for the content container.
+     * Use 'region' for landmark-style popovers; 'dialog' for interactive surfaces.
+     * @default 'dialog'
+     */
+    role?: string;
+    /**
+     * Focus policy on open.
+     * @default 'first'
+     */
+    focusPolicy?: PopoverFocusPolicy;
+    /** Portal target element. Defaults to document.body. */
+    container?: HTMLElement | null;
+    /** Remove default visual styles */
+    unstyled?: boolean;
+}
+interface PopoverCloseProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare function PopoverRoot({ open: controlledOpen, defaultOpen, onOpenChange, disabled, children, }: PopoverProps): react_jsx_runtime.JSX.Element;
+/**
+ * Accessible, non-modal Popover.
+ *
+ * Keyboard contract:
+ * - **Enter / Space** on trigger → open
+ * - **Escape** (from anywhere inside) → close, return focus to trigger
+ * - **Tab / Shift+Tab** → move freely through content (no trap)
+ * - **Click outside** → close; focus stays where the user clicked
+ *
+ * @example
+ * ```tsx
+ * <Popover>
+ *   <Popover.Trigger>Open</Popover.Trigger>
+ *   <Popover.Content aria-label="Settings panel" placement="bottom-start">
+ *     <p>Content here.</p>
+ *     <Popover.Close>Dismiss</Popover.Close>
+ *   </Popover.Content>
+ * </Popover>
+ * ```
+ */
+declare const Popover: typeof PopoverRoot & {
+    Trigger: React__default.ForwardRefExoticComponent<PopoverTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+    Content: React__default.ForwardRefExoticComponent<PopoverContentProps & React__default.RefAttributes<HTMLDivElement>>;
+    Close: React__default.ForwardRefExoticComponent<PopoverCloseProps & React__default.RefAttributes<HTMLButtonElement>>;
+};
+/** Same as Popover, exported for named compound imports */
+declare const PopoverCompound: typeof PopoverRoot & {
+    Trigger: React__default.ForwardRefExoticComponent<PopoverTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+    Content: React__default.ForwardRefExoticComponent<PopoverContentProps & React__default.RefAttributes<HTMLDivElement>>;
+    Close: React__default.ForwardRefExoticComponent<PopoverCloseProps & React__default.RefAttributes<HTMLButtonElement>>;
+};
+
+interface PopoverContextValue {
+    /** Whether the popover is open */
+    isOpen: boolean;
+    /** Toggle or set open state */
+    onOpenChange: (open: boolean) => void;
+    /** Stable IDs */
+    triggerId: string;
+    contentId: string;
+    /** Ref to the trigger element (for positioning + focus return) */
+    triggerRef: RefObject<HTMLElement | null>;
+    /** Whether the popover trigger is disabled */
+    disabled: boolean;
+    /**
+     * Called by Popover.Content to signal it is mounted in the DOM.
+     * Trigger uses this to set aria-controls only when content exists.
+     */
+    setContentMounted: (mounted: boolean) => void;
+    /** True when Popover.Content is mounted */
+    contentMounted: boolean;
+}
+declare function usePopoverContext(): PopoverContextValue;
+
+interface AccordionProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Whether one or multiple items can be open at once.
+     * @default 'single'
+     */
+    type?: 'single' | 'multiple';
+    /**
+     * Whether the open item can be collapsed when clicked again (single mode only).
+     * @default false
+     */
+    collapsible?: boolean;
+    /**
+     * Controlled open item(s). String for single mode, string[] for multiple mode.
+     */
+    value?: string | string[];
+    /**
+     * Default open item(s) for uncontrolled usage.
+     */
+    defaultValue?: string | string[];
+    /**
+     * Called when the open item(s) change. Receives a string in single mode,
+     * string[] in multiple mode.
+     */
+    onValueChange?: (value: string | string[]) => void;
+    /**
+     * Heading level used by Accordion.Header (h2–h6).
+     * @default 3
+     */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    children: React__default.ReactNode;
+}
+/**
+ * Accessible accordion component. Expand/collapse sections of content.
+ *
+ * @example
+ * ```tsx
+ * <Accordion defaultValue="item-1" headingLevel={3}>
+ *   <Accordion.Item value="item-1">
+ *     <Accordion.Header>
+ *       <Accordion.Trigger>Section 1</Accordion.Trigger>
+ *     </Accordion.Header>
+ *     <Accordion.Content>Content 1</Accordion.Content>
+ *   </Accordion.Item>
+ * </Accordion>
+ * ```
+ *
+ * Keyboard: Arrow Up/Down to move between headers, Home/End for first/last,
+ * Enter/Space to toggle. Disabled items are skipped by keyboard navigation.
+ */
+declare const Accordion: React__default.ForwardRefExoticComponent<AccordionProps & React__default.RefAttributes<HTMLDivElement>>;
+interface AccordionItemProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /** Unique value identifying this item */
+    value: string;
+    /** Whether this item is disabled */
+    disabled?: boolean;
+    children: React__default.ReactNode;
+}
+/**
+ * A single accordion item. Must be a direct child of Accordion.
+ * Contains Accordion.Header (with Accordion.Trigger inside) and Accordion.Content.
+ */
+declare const AccordionItem: React__default.ForwardRefExoticComponent<AccordionItemProps & React__default.RefAttributes<HTMLDivElement>>;
+interface AccordionHeaderProps extends React__default.HTMLAttributes<HTMLHeadingElement> {
+    /**
+     * Override the heading level for this specific header (h2–h6).
+     * Defaults to the `headingLevel` set on the parent `<Accordion>`.
+     */
+    level?: 2 | 3 | 4 | 5 | 6;
+    children: React__default.ReactNode;
+}
+/**
+ * Semantic heading wrapper for an accordion trigger.
+ * Renders an `<h{level}>` element so the trigger button is correctly nested
+ * inside a heading — fulfilling WCAG 1.3.1 and the ARIA authoring practices.
+ *
+ * Must be used inside Accordion.Item.
+ *
+ * @example
+ * ```tsx
+ * <Accordion.Header>
+ *   <Accordion.Trigger>Section Title</Accordion.Trigger>
+ * </Accordion.Header>
+ * ```
+ */
+declare const AccordionHeader: React__default.ForwardRefExoticComponent<AccordionHeaderProps & React__default.RefAttributes<HTMLHeadingElement>>;
+interface AccordionTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React__default.ReactNode;
+}
+/**
+ * The button that toggles an accordion item's panel.
+ * Must be used inside Accordion.Header (which must be inside Accordion.Item).
+ *
+ * All ARIA wiring (aria-expanded, aria-controls, id) is applied automatically.
+ * Provide visible label text — no aria-label needed for typical usage.
+ */
+declare const AccordionTrigger: React__default.ForwardRefExoticComponent<AccordionTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+interface AccordionContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /** Keep content mounted in the DOM even when closed */
+    forceMount?: boolean;
+    children: React__default.ReactNode;
+}
+/**
+ * The collapsible content panel for an accordion item.
+ * Must be used inside Accordion.Item.
+ *
+ * When closed, the panel is hidden from visual users, keyboard users, and
+ * assistive technologies via the HTML `hidden` attribute.
+ * Use `forceMount` to keep the DOM node alive (e.g., for CSS transitions).
+ */
+declare const AccordionContent: React__default.ForwardRefExoticComponent<AccordionContentProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const AccordionCompound: React__default.ForwardRefExoticComponent<AccordionProps & React__default.RefAttributes<HTMLDivElement>> & {
+    Item: React__default.ForwardRefExoticComponent<AccordionItemProps & React__default.RefAttributes<HTMLDivElement>>;
+    Header: React__default.ForwardRefExoticComponent<AccordionHeaderProps & React__default.RefAttributes<HTMLHeadingElement>>;
+    Trigger: React__default.ForwardRefExoticComponent<AccordionTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+    Content: React__default.ForwardRefExoticComponent<AccordionContentProps & React__default.RefAttributes<HTMLDivElement>>;
+};
+
+interface AccordionContextValue {
+    /** Currently open item values */
+    openItems: string[];
+    /** Toggle an item open/closed */
+    toggleItem: (value: string) => void;
+    /** Whether one or multiple items can be open */
+    type: 'single' | 'multiple';
+    /** Whether the open item can be collapsed in single mode */
+    collapsible: boolean;
+    /** Base ID for ARIA relationships */
+    baseId: string;
+    /** Heading level rendered by Accordion.Header (2–6) */
+    headingLevel: 2 | 3 | 4 | 5 | 6;
+}
+declare function useAccordionContext(): AccordionContextValue;
+interface AccordionItemContextValue {
+    /** Value identifying this item */
+    value: string;
+    /** Whether the panel is currently open */
+    isOpen: boolean;
+    /** Whether the item is disabled */
+    isDisabled: boolean;
+    /** ID for the trigger button */
+    triggerId: string;
+    /** ID for the content panel */
+    contentId: string;
+}
+declare function useAccordionItemContext(): AccordionItemContextValue;
+
+type SortDirection = 'ascending' | 'descending' | 'none';
+interface TableContextValue {
+    /** Stable base ID for generating unique child element IDs */
+    baseId: string;
+    /** Currently sorted column key, or null if unsorted */
+    sortKey: string | null;
+    /** Sort direction for the active sorted column */
+    sortDirection: SortDirection;
+    /** Called when a sortable column header is activated */
+    onSort: ((key: string) => void) | null;
+    /** Set of currently selected row IDs */
+    selectedRows: Set<string>;
+    /** Called when selection changes; receives new array of selected IDs */
+    onSelectionChange: ((rows: string[]) => void) | null;
+    /** Whether the table is in a loading state */
+    isLoading: boolean;
+}
+declare function useTableContext(): TableContextValue;
+type TableSection = 'head' | 'body' | 'foot';
+interface TableSectionContextValue {
+    section: TableSection;
+}
+declare function useTableSectionContext(): TableSectionContextValue | null;
+interface TableRowContextValue {
+    /** The row's unique ID (required for selection) */
+    rowId: string | null;
+    /** Whether this row is currently selected */
+    isSelected: boolean;
+}
+declare function useTableRowContext(): TableRowContextValue | null;
+
+interface TableProps extends React__default.TableHTMLAttributes<HTMLTableElement> {
+    /**
+     * Accessible name for the table, rendered as a `<caption>` element.
+     * Required unless `aria-label` or `aria-labelledby` is provided.
+     */
+    caption?: string;
+    /**
+     * Hides the caption visually while keeping it accessible to screen readers.
+     * @default false
+     */
+    captionHidden?: boolean;
+    /**
+     * Controlled sort column key. Pass `null` to clear sort.
+     */
+    sortKey?: string | null;
+    /**
+     * Direction of the controlled sort.
+     * @default 'none'
+     */
+    sortDirection?: SortDirection;
+    /**
+     * Called when a sortable header is activated. Receives the column key and
+     * new direction. Direction cycles: none → ascending → descending → none.
+     */
+    onSortChange?: (key: string | null, direction: SortDirection) => void;
+    /**
+     * Controlled array of selected row IDs.
+     */
+    selectedRows?: string[];
+    /**
+     * Default selected row IDs for uncontrolled usage.
+     */
+    defaultSelectedRows?: string[];
+    /**
+     * Called when row selection changes.
+     */
+    onSelectionChange?: (rows: string[]) => void;
+    /**
+     * When `true`, the table communicates a loading state via `aria-busy`.
+     * @default false
+     */
+    isLoading?: boolean;
+    children: React__default.ReactNode;
+}
+/**
+ * Accessible data table component. Renders native semantic HTML table elements
+ * with automatic ARIA wiring for sorting and selection.
+ *
+ * @example
+ * ```tsx
+ * <Table caption="Active users" sortKey={key} sortDirection={dir} onSortChange={handleSort}>
+ *   <Table.Head>
+ *     <Table.Row>
+ *       <Table.Header sortKey="name">Name</Table.Header>
+ *       <Table.Header>Role</Table.Header>
+ *     </Table.Row>
+ *   </Table.Head>
+ *   <Table.Body>
+ *     {users.map(u => (
+ *       <Table.Row key={u.id} rowId={u.id}>
+ *         <Table.Cell>{u.name}</Table.Cell>
+ *         <Table.Cell>{u.role}</Table.Cell>
+ *       </Table.Row>
+ *     ))}
+ *   </Table.Body>
+ * </Table>
+ * ```
+ */
+declare const Table: React__default.ForwardRefExoticComponent<TableProps & React__default.RefAttributes<HTMLTableElement>>;
+interface TableHeadProps extends React__default.HTMLAttributes<HTMLTableSectionElement> {
+    children: React__default.ReactNode;
+}
+/**
+ * Wraps `<thead>`. Column headers inside are automatically assigned
+ * `scope="col"`.
+ */
+declare const TableHead: React__default.ForwardRefExoticComponent<TableHeadProps & React__default.RefAttributes<HTMLTableSectionElement>>;
+interface TableBodyProps extends React__default.HTMLAttributes<HTMLTableSectionElement> {
+    children: React__default.ReactNode;
+}
+/**
+ * Wraps `<tbody>`. Row headers inside (Table.Header) are automatically
+ * assigned `scope="row"`.
+ */
+declare const TableBody: React__default.ForwardRefExoticComponent<TableBodyProps & React__default.RefAttributes<HTMLTableSectionElement>>;
+interface TableFootProps extends React__default.HTMLAttributes<HTMLTableSectionElement> {
+    children: React__default.ReactNode;
+}
+/**
+ * Wraps `<tfoot>`.
+ */
+declare const TableFoot: React__default.ForwardRefExoticComponent<TableFootProps & React__default.RefAttributes<HTMLTableSectionElement>>;
+interface TableRowProps extends React__default.HTMLAttributes<HTMLTableRowElement> {
+    /**
+     * Unique identifier for this row. Required when using row selection
+     * (Table.SelectCell / Table.SelectAllCell).
+     */
+    rowId?: string;
+    children: React__default.ReactNode;
+}
+/**
+ * Renders a `<tr>`. When `rowId` is supplied and the table is selectable,
+ * `aria-selected` is applied automatically.
+ */
+declare const TableRow: React__default.ForwardRefExoticComponent<TableRowProps & React__default.RefAttributes<HTMLTableRowElement>>;
+interface TableHeaderProps extends React__default.ThHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * When provided, the header becomes a sort control. The column key is
+     * passed to `onSortChange`. `aria-sort` and the sort button are managed
+     * automatically — no consumer ARIA wiring needed.
+     */
+    sortKey?: string;
+    /**
+     * Override the auto-detected `scope` attribute.
+     * - In `Table.Head`: defaults to `"col"`
+     * - In `Table.Body` / `Table.Foot`: defaults to `"row"`
+     */
+    scope?: 'col' | 'row' | 'colgroup' | 'rowgroup';
+    children?: React__default.ReactNode;
+}
+/**
+ * Renders a `<th>` with auto-applied `scope`. When `sortKey` is supplied,
+ * a native `<button>` with correct `aria-sort` state is rendered inside the
+ * header — no manual ARIA required.
+ */
+declare const TableHeader: React__default.ForwardRefExoticComponent<TableHeaderProps & React__default.RefAttributes<HTMLTableCellElement>>;
+interface TableCellProps extends React__default.TdHTMLAttributes<HTMLTableCellElement> {
+    children?: React__default.ReactNode;
+}
+/**
+ * Renders a `<td>` data cell. Use `Table.Header` for row-header cells.
+ */
+declare const TableCell: React__default.ForwardRefExoticComponent<TableCellProps & React__default.RefAttributes<HTMLTableCellElement>>;
+interface TableSelectAllCellProps extends React__default.ThHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * All selectable row IDs. Used to compute `checked` / `indeterminate`
+     * state and to pass the complete list to `onSelectionChange` when
+     * "select all" is activated.
+     */
+    rowIds: string[];
+}
+/**
+ * Renders a `<th scope="col">` containing a "Select all rows" checkbox.
+ * Automatically manages checked and indeterminate states.
+ * Must be placed inside `Table.Head > Table.Row`.
+ */
+declare const TableSelectAllCell: React__default.ForwardRefExoticComponent<TableSelectAllCellProps & React__default.RefAttributes<HTMLTableCellElement>>;
+interface TableSelectCellProps extends React__default.TdHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * Accessible label for this checkbox, e.g. "Select Alice".
+     * Required — a dev warning is shown in development if omitted.
+     */
+    label: string;
+}
+/**
+ * Renders a `<td>` containing a row-selection checkbox.
+ * Must be placed inside `Table.Body > Table.Row` that has a `rowId` prop.
+ * The `label` prop is required for accessibility.
+ */
+declare const TableSelectCell: React__default.ForwardRefExoticComponent<TableSelectCellProps & React__default.RefAttributes<HTMLTableCellElement>>;
+interface TableEmptyStateProps extends React__default.HTMLAttributes<HTMLTableRowElement> {
+    /** Number of columns the empty cell should span */
+    colSpan: number;
+    children?: React__default.ReactNode;
+}
+/**
+ * Renders a single full-width `<tr>` for empty-table states.
+ * Place inside `Table.Body` in place of data rows.
+ */
+declare const TableEmptyState: React__default.ForwardRefExoticComponent<TableEmptyStateProps & React__default.RefAttributes<HTMLTableRowElement>>;
+interface TableLoadingStateProps extends React__default.HTMLAttributes<HTMLTableRowElement> {
+    /** Number of columns the loading cell should span */
+    colSpan: number;
+    children?: React__default.ReactNode;
+}
+/**
+ * Renders a single full-width `<tr>` with `aria-busy="true"` for loading states.
+ * Place inside `Table.Body` in place of data rows.
+ */
+declare const TableLoadingState: React__default.ForwardRefExoticComponent<TableLoadingStateProps & React__default.RefAttributes<HTMLTableRowElement>>;
+declare const TableCompound: React__default.ForwardRefExoticComponent<TableProps & React__default.RefAttributes<HTMLTableElement>> & {
+    Head: React__default.ForwardRefExoticComponent<TableHeadProps & React__default.RefAttributes<HTMLTableSectionElement>>;
+    Body: React__default.ForwardRefExoticComponent<TableBodyProps & React__default.RefAttributes<HTMLTableSectionElement>>;
+    Foot: React__default.ForwardRefExoticComponent<TableFootProps & React__default.RefAttributes<HTMLTableSectionElement>>;
+    Row: React__default.ForwardRefExoticComponent<TableRowProps & React__default.RefAttributes<HTMLTableRowElement>>;
+    Header: React__default.ForwardRefExoticComponent<TableHeaderProps & React__default.RefAttributes<HTMLTableCellElement>>;
+    Cell: React__default.ForwardRefExoticComponent<TableCellProps & React__default.RefAttributes<HTMLTableCellElement>>;
+    SelectAllCell: React__default.ForwardRefExoticComponent<TableSelectAllCellProps & React__default.RefAttributes<HTMLTableCellElement>>;
+    SelectCell: React__default.ForwardRefExoticComponent<TableSelectCellProps & React__default.RefAttributes<HTMLTableCellElement>>;
+    EmptyState: React__default.ForwardRefExoticComponent<TableEmptyStateProps & React__default.RefAttributes<HTMLTableRowElement>>;
+    LoadingState: React__default.ForwardRefExoticComponent<TableLoadingStateProps & React__default.RefAttributes<HTMLTableRowElement>>;
+};
+
+interface FormFieldProps {
+    /** Visible label text — renders a <FormField.Label> automatically when provided */
+    label?: ReactNode;
+    /** Hint text below the control */
+    hint?: ReactNode;
+    /** Error message — sets aria-invalid on control when present */
+    error?: ReactNode;
+    /** Mark the field as required */
+    required?: boolean;
+    /** Disable the field */
+    disabled?: boolean;
+    /** Remove default styles for full customization */
+    unstyled?: boolean;
+    /** Children: use FormField sub-components */
+    children?: ReactNode;
+    /** CSS class name for the wrapper */
+    className?: string;
+    /** Inline styles for the wrapper */
+    style?: React__default.CSSProperties;
+    /** Override the auto-generated control id */
+    id?: string;
+}
+/** Props passed to the render-prop child of FormField.Control */
+interface FormFieldControlRenderProps {
+    /** The id to set on the control element (matches the label's htmlFor) */
+    controlId: string;
+    /** Spread these onto the control for full ARIA wiring */
+    ariaProps: {
+        'aria-labelledby'?: string;
+        'aria-describedby'?: string;
+        'aria-invalid'?: true;
+        'aria-required'?: true;
+        'aria-disabled'?: true;
+    };
+}
+interface FormFieldLabelProps extends React__default.HTMLAttributes<HTMLLabelElement> {
+    children?: ReactNode;
+}
+interface FormFieldHintProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+interface FormFieldErrorProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+interface FormFieldControlProps {
+    children: (props: FormFieldControlRenderProps) => ReactNode;
+}
+/**
+ * FormField.Control — render-prop that provides the control ID and ARIA props.
+ *
+ * @example
+ * ```tsx
+ * <FormField.Control>
+ *   {({ controlId, ariaProps }) => (
+ *     <input id={controlId} type="text" {...ariaProps} />
+ *   )}
+ * </FormField.Control>
+ * ```
+ */
+declare function FormFieldControl({ children }: FormFieldControlProps): react_jsx_runtime.JSX.Element;
+declare namespace FormFieldControl {
+    var displayName: string;
+}
+declare const FormField: React__default.ForwardRefExoticComponent<FormFieldProps & React__default.RefAttributes<HTMLDivElement>> & {
+    Label: React__default.ForwardRefExoticComponent<FormFieldLabelProps & React__default.RefAttributes<HTMLLabelElement>>;
+    Hint: React__default.ForwardRefExoticComponent<FormFieldHintProps & React__default.RefAttributes<HTMLDivElement>>;
+    Error: React__default.ForwardRefExoticComponent<FormFieldErrorProps & React__default.RefAttributes<HTMLDivElement>>;
+    Control: typeof FormFieldControl;
+};
+declare const FormFieldCompound: React__default.ForwardRefExoticComponent<FormFieldProps & React__default.RefAttributes<HTMLDivElement>> & {
+    Label: React__default.ForwardRefExoticComponent<FormFieldLabelProps & React__default.RefAttributes<HTMLLabelElement>>;
+    Hint: React__default.ForwardRefExoticComponent<FormFieldHintProps & React__default.RefAttributes<HTMLDivElement>>;
+    Error: React__default.ForwardRefExoticComponent<FormFieldErrorProps & React__default.RefAttributes<HTMLDivElement>>;
+    Control: typeof FormFieldControl;
+};
+
+interface FormFieldContextValue {
+    /** ID for the form control (used in label htmlFor) */
+    controlId: string;
+    /** ID for the label element */
+    labelId: string;
+    /** ID for the hint element */
+    hintId: string;
+    /** ID for the error element */
+    errorId: string;
+    /** Whether an error is present */
+    hasError: boolean;
+    /** Whether a hint sub-component is mounted */
+    hasHint: boolean;
+    /** Register hint presence from sub-component */
+    setHasHint: (value: boolean) => void;
+    /** Whether the field is required */
+    required: boolean;
+    /** Whether the field is disabled */
+    disabled: boolean;
+    /** Whether to remove default styles */
+    unstyled: boolean;
+}
+declare function useFormFieldContext(): FormFieldContextValue;
+
+export { AccordionCompound as Accordion, Accordion as AccordionBase, AccordionContent, type AccordionContentProps, type AccordionContextValue, AccordionHeader, type AccordionHeaderProps, AccordionItem, type AccordionItemContextValue, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, Alert, type AlertProps, type AlertType, Button, type ButtonProps, CheckboxCompound as Checkbox, Checkbox as CheckboxBase, CheckboxGroup, type CheckboxGroupContextValue, type CheckboxGroupProps, CheckboxIndicator, type CheckboxIndicatorProps, type CheckboxProps, FormField, FormFieldCompound, type FormFieldContextValue, type FormFieldControlProps, type FormFieldControlRenderProps, type FormFieldErrorProps, type FormFieldHintProps, type FormFieldLabelProps, type FormFieldProps, Heading, type HeadingProps, InputCompound as Input, Input as InputBase, type InputContextValue, InputError, type InputErrorProps, InputField, type InputFieldProps, InputHint, type InputHintProps, InputLabel, type InputLabelProps, type InputProps, Link, type LinkProps, ListboxCompound as Listbox, Listbox as ListboxBase, type ListboxContextValue, ListboxGroup, type ListboxGroupProps, ListboxOption, type ListboxOptionProps, type ListboxProps, Popover, type PopoverCloseProps, PopoverCompound, type PopoverContentProps, type PopoverContextValue, type PopoverPlacement, type PopoverProps, type PopoverTriggerProps, Radio, RadioGroupCompound as RadioGroup, RadioGroup as RadioGroupBase, type RadioGroupContextValue, type RadioGroupProps, type RadioProps, type RovingTabindexItem, SelectCompound as Select, Select as SelectBase, SelectListbox, type SelectListboxProps, SelectOptionItem, type SelectOptionProps, type SelectOption as SelectOptionType, type SelectProps, SelectTrigger, type SelectTriggerProps, SkipLink, type SkipLinkProps, type SortDirection, Switch, type SwitchProps, TableCompound as Table, Table as TableBase, TableBody, type TableBodyProps, TableCell, type TableCellProps, type TableContextValue, TableEmptyState, type TableEmptyStateProps, TableFoot, type TableFootProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, TableLoadingState, type TableLoadingStateProps, type TableProps, TableRow, type TableRowContextValue, type TableRowProps, type TableSection, type TableSectionContextValue, TableSelectAllCell, type TableSelectAllCellProps, TableSelectCell, type TableSelectCellProps, Text, type TextProps, TextareaCompound as Textarea, Textarea as TextareaBase, type TextareaContextValue, TextareaError, type TextareaErrorProps, TextareaField, type TextareaFieldProps, TextareaHint, type TextareaHintProps, TextareaLabel, type TextareaLabelProps, type TextareaProps, type UseFocusTrapOptions, type UseRovingTabindexOptions, VisuallyHidden, type VisuallyHiddenProps, useAccordionContext, useAccordionItemContext, useAnnounceLoading, useAnnounceOnChange, useAnnouncer, useCheckboxGroupContext, useFocusControl, useFocusManager, useFocusNeighbor, useFocusReturn, useFocusTrap, useFocusTrapControls, useFocusVisible, useFocusWithin, useFormFieldContext, useGridKeyboard, useId, useIdScope, useIds, useInputContext, useKeyPressed, useKeyboard, useListboxContext, useMenuKeyboard, usePopoverContext, useRadioGroupContext, useRovingTabindex, useRovingTabindexMap, useTableContext, useTableRowContext, useTableSectionContext, useTabsKeyboard, useTextareaContext, useTypeAhead };