@omniviewdev/base-ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4392 @@
+import { AlertDialog as AlertDialog_2 } from '@base-ui/react/alert-dialog';
+import { AnchorHTMLAttributes } from 'react';
+import { Autocomplete as Autocomplete_2 } from '@base-ui/react/autocomplete';
+import { AutocompleteEmptyProps } from '@base-ui/react';
+import { AutocompleteGroupLabelProps } from '@base-ui/react';
+import { AutocompletePositionerProps } from '@base-ui/react';
+import { Avatar as Avatar_2 } from '@base-ui/react/avatar';
+import { Button as Button_2 } from '@base-ui/react/button';
+import { ButtonHTMLAttributes } from 'react';
+import { ChangeEventHandler } from 'react';
+import { Checkbox as Checkbox_2 } from '@base-ui/react/checkbox';
+import { CheckboxGroup as CheckboxGroup_2 } from '@base-ui/react/checkbox-group';
+import { ColumnDef as ColumnDef_2 } from '@tanstack/react-table';
+import { ColumnOrderState } from '@tanstack/react-table';
+import { ColumnPinningState } from '@tanstack/react-table';
+import { ColumnSizingState } from '@tanstack/react-table';
+import { Combobox as Combobox_2 } from '@base-ui/react/combobox';
+import { ComboboxChipsProps } from '@base-ui/react';
+import { ComboboxItemIndicatorProps } from '@base-ui/react';
+import { ComponentProps } from 'react';
+import { ComponentPropsWithoutRef } from 'react';
+import { ComponentPropsWithRef } from 'react';
+import { ContextMenu as ContextMenu_2 } from '@base-ui/react/context-menu';
+import { ContextMenuBackdropProps } from '@base-ui/react';
+import { ContextMenuCheckboxItemIndicatorProps } from '@base-ui/react';
+import { ContextMenuGroupLabelProps } from '@base-ui/react';
+import { ContextMenuPositionerProps } from '@base-ui/react';
+import { ContextMenuRadioItemIndicatorProps } from '@base-ui/react';
+import { CSSProperties } from 'react';
+import { DialogBackdropProps } from '@base-ui/react';
+import { DialogDescriptionProps } from '@base-ui/react';
+import { DialogTitleProps as DialogTitleProps_2 } from '@base-ui/react';
+import { DragEndEvent } from '@dnd-kit/core';
+import { ElementType } from 'react';
+import { ExpandedState } from '@tanstack/react-table';
+import { Field } from '@base-ui/react/field';
+import { FieldControlProps } from '@base-ui/react';
+import { FieldDescriptionProps } from '@base-ui/react';
+import { FieldErrorProps } from '@base-ui/react';
+import { FieldLabelProps } from '@base-ui/react';
+import { FieldsetHTMLAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributes } from 'react';
+import { ImgHTMLAttributes } from 'react';
+import { Input as Input_2 } from '@base-ui/react/input';
+import { JSX } from 'react/jsx-runtime';
+import { LabelHTMLAttributes } from 'react';
+import { Menu as Menu_2 } from '@base-ui/react/menu';
+import { NamedExoticComponent } from 'react';
+import { NumberField } from '@base-ui/react/number-field';
+import { PaginationState } from '@tanstack/react-table';
+import { Popover as Popover_2 } from '@base-ui/react/popover';
+import { PopoverBackdropProps } from '@base-ui/react';
+import { PopoverDescriptionProps } from '@base-ui/react';
+import { PopoverPortalProps } from '@base-ui/react';
+import { PopoverPositionerProps } from '@base-ui/react';
+import { PopoverTitleProps } from '@base-ui/react';
+import { PropsWithChildren } from 'react';
+import { PropsWithoutRef } from 'react';
+import { Radio as Radio_2 } from '@base-ui/react/radio';
+import { RadioGroup as RadioGroup_2 } from '@base-ui/react/radio-group';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { Ref } from 'react';
+import { RefAttributes } from 'react';
+import { RefCallback } from 'react';
+import { RefObject } from 'react';
+import { RowSelectionState } from '@tanstack/react-table';
+import { Select as Select_2 } from '@base-ui/react/select';
+import { SelectArrowProps } from '@base-ui/react';
+import { SelectBackdropProps } from '@base-ui/react';
+import { SelectGroupLabelProps } from '@base-ui/react';
+import { SelectItemIndicatorProps } from '@base-ui/react';
+import { SelectItemTextProps } from '@base-ui/react';
+import { SelectPositionerProps } from '@base-ui/react';
+import { SelectScrollDownArrowProps } from '@base-ui/react';
+import { SelectScrollUpArrowProps } from '@base-ui/react';
+import { Separator as Separator_2 } from '@base-ui/react/separator';
+import { SeparatorProps as SeparatorProps_2 } from '@base-ui/react';
+import { Slider as Slider_2 } from '@base-ui/react/slider';
+import { SortingState } from '@tanstack/react-table';
+import { Switch as Switch_2 } from '@base-ui/react/switch';
+import { Table as Table_2 } from '@tanstack/react-table';
+import { TableHTMLAttributes } from 'react';
+import { TableState } from '@tanstack/react-table';
+import { Tabs as Tabs_2 } from '@base-ui/react/tabs';
+import { TabsIndicatorProps as TabsIndicatorProps_2 } from '@base-ui/react';
+import { TabsListProps as TabsListProps_2 } from '@base-ui/react';
+import { TabsPanelProps as TabsPanelProps_2 } from '@base-ui/react';
+import { TdHTMLAttributes } from 'react';
+import { TextareaHTMLAttributes } from 'react';
+import { ThHTMLAttributes } from 'react';
+import { Toggle } from '@base-ui/react/toggle';
+import { ToggleGroup } from '@base-ui/react/toggle-group';
+import { Tooltip as Tooltip_2 } from '@base-ui/react/tooltip';
+import { TooltipPortalProps } from '@base-ui/react';
+import { TooltipPositionerProps } from '@base-ui/react';
+import { VirtualItem } from '@tanstack/react-virtual';
+import { VisibilityState } from '@tanstack/react-table';
+
+export declare const Accordion: AccordionCompound;
+
+export declare type AccordionAnimation = 'default' | 'fast' | 'none';
+
+declare type AccordionCompound = typeof AccordionRoot & {
+    Item: typeof AccordionItem;
+};
+
+declare const AccordionItem: ForwardRefExoticComponent<AccordionItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AccordionItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Unique identifier for this item. */
+    id: string;
+    /** Header text. */
+    title: string;
+    /** Optional leading icon in the header. */
+    icon?: ReactNode;
+    /** Displayed as a small badge/count on the header. */
+    count?: number;
+    /** Trailing content slot on the header row. */
+    endDecorator?: ReactNode;
+    /** Whether this individual item starts expanded. */
+    defaultExpanded?: boolean;
+    /** Prevents toggling. */
+    disabled?: boolean;
+    /** Remove default padding from the content area. */
+    disableContentPadding?: boolean;
+}
+
+export declare interface AccordionProps extends HTMLAttributes<HTMLDivElement> {
+    /** Only one item open at a time. */
+    exclusive?: boolean;
+    /** IDs of initially expanded items. */
+    defaultExpanded?: string[];
+    /** Animation speed for expand/collapse. */
+    animation?: AccordionAnimation;
+    /** Size preset — controls header density and font size. */
+    size?: AccordionSize;
+    /** Visual variant. `flush` gives edge-to-edge bold uppercase headers for sidebar/panel use. */
+    variant?: AccordionVariant;
+}
+
+declare const AccordionRoot: ForwardRefExoticComponent<AccordionProps & RefAttributes<HTMLDivElement>>;
+
+export declare type AccordionSize = 'sm' | 'md' | 'lg';
+
+export declare type AccordionVariant = 'default' | 'flush';
+
+export declare const ActionList: ActionListCompound;
+
+declare type ActionListCompound = typeof ActionListRoot & {
+    Item: typeof ActionListItem;
+    GroupLabel: typeof ActionListGroupLabel;
+    Separator: typeof ActionListSeparator;
+};
+
+declare const ActionListGroupLabel: ForwardRefExoticComponent<ActionListGroupLabelProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ActionListGroupLabelProps = HTMLAttributes<HTMLDivElement>;
+
+declare const ActionListItem: ForwardRefExoticComponent<Omit<ActionListItemProps, "ref"> & RefAttributes<HTMLElement>>;
+
+export declare interface ActionListItemProps extends Omit<ButtonProps, 'children'> {
+    children?: ReactNode;
+    label?: ReactNode;
+    description?: ReactNode;
+    leadingIcon?: ReactNode;
+    trailingContent?: ReactNode;
+    icon?: ReactNode;
+    shortcut?: ReactNode;
+    /** @deprecated Use `leadingIcon` */
+    startAdornment?: ReactNode;
+    /** @deprecated Use `trailingContent` */
+    endAdornment?: ReactNode;
+}
+
+declare type ActionListItemVariant = NonNullable<ComponentVariant>;
+
+export declare interface ActionListProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color' | 'role'>, Pick<StyledComponentProps, 'color' | 'size'> {
+    itemVariant?: ActionListItemVariant;
+}
+
+declare const ActionListRoot: ForwardRefExoticComponent<ActionListProps & RefAttributes<HTMLDivElement>>;
+
+declare const ActionListSeparator: ForwardRefExoticComponent<ActionListSeparatorProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ActionListSeparatorProps = HTMLAttributes<HTMLDivElement>;
+
+export declare const AlertDialog: AlertDialogCompound;
+
+declare const AlertDialogBackdrop: ForwardRefExoticComponent<Omit<Omit<DialogBackdropProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const AlertDialogClose: ForwardRefExoticComponent<AlertDialogCloseProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface AlertDialogCloseProps extends Omit<ComponentPropsWithoutRef<typeof AlertDialog_2.Close>, 'color'>, StyledComponentProps {
+}
+
+declare type AlertDialogCompound = typeof AlertDialogRoot & {
+    Root: typeof AlertDialogRoot;
+    Backdrop: typeof AlertDialogBackdrop;
+    Close: typeof AlertDialogClose;
+    Description: typeof AlertDialogDescription;
+    Handle: typeof AlertDialog_2.Handle;
+    Popup: typeof AlertDialogPopup;
+    Portal: typeof AlertDialog_2.Portal;
+    Title: typeof AlertDialogTitle;
+    Trigger: typeof AlertDialogTrigger;
+    Viewport: typeof AlertDialog_2.Viewport;
+    createHandle: typeof AlertDialog_2.createHandle;
+};
+
+declare const AlertDialogDescription: ForwardRefExoticComponent<Omit<Omit<DialogDescriptionProps, "ref"> & RefAttributes<HTMLParagraphElement>, "ref"> & RefAttributes<HTMLParagraphElement>>;
+
+declare const AlertDialogPopup: ForwardRefExoticComponent<AlertDialogPopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AlertDialogPopupProps extends Omit<ComponentPropsWithoutRef<typeof AlertDialog_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const AlertDialogRoot: {
+    ({ variant, color, size, ...props }: AlertDialogRootProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface AlertDialogRootProps extends Omit<ComponentPropsWithoutRef<typeof AlertDialog_2.Root>, 'color'>, StyledComponentProps {
+}
+
+declare const AlertDialogTitle: ForwardRefExoticComponent<Omit<Omit<DialogTitleProps_2, "ref"> & RefAttributes<HTMLHeadingElement>, "ref"> & RefAttributes<HTMLHeadingElement>>;
+
+declare const AlertDialogTrigger: {
+    ({ className, variant, color, size, ...props }: AlertDialogTriggerProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface AlertDialogTriggerProps extends Omit<ComponentPropsWithoutRef<typeof AlertDialog_2.Trigger>, 'color'>, StyledComponentProps {
+}
+
+export declare const AppShell: AppShellCompound;
+
+declare type AppShellCompound = typeof AppShellRoot & {
+    Header: typeof Header;
+    Sidebar: typeof Sidebar;
+    Content: typeof Content;
+    Footer: typeof Footer;
+    NavRail: typeof NavRail;
+    SecondarySidebar: typeof SecondarySidebar;
+};
+
+export declare interface AppShellContentProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+
+export declare interface AppShellFooterProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+
+export declare interface AppShellHeaderProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+
+declare interface AppShellNavRailProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+
+export declare interface AppShellProps extends HTMLAttributes<HTMLDivElement> {
+    /** Width of the sidebar. Default: 240px. */
+    sidebarWidth?: number | string;
+    /** Whether the sidebar is collapsed. */
+    sidebarCollapsed?: boolean;
+    /** Position of the sidebar. Default: 'left'. */
+    sidebarPosition?: 'left' | 'right';
+    /** Height of the header. Default: 40px. */
+    headerHeight?: number | string;
+    /** Height of the footer. Default: 24px. */
+    footerHeight?: number | string;
+    /** Width of the nav rail. Default: 48px. Only used when NavRail is present. */
+    navRailWidth?: number | string;
+    /** Width of the secondary sidebar. Default: 300px. */
+    secondarySidebarWidth?: number | string;
+    /** Whether the secondary sidebar is collapsed. */
+    secondarySidebarCollapsed?: boolean;
+    children?: ReactNode;
+}
+
+declare const AppShellRoot: ForwardRefExoticComponent<AppShellProps & RefAttributes<HTMLDivElement>>;
+
+declare interface AppShellSecondarySidebarProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+
+export declare interface AppShellSidebarProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+
+export declare const AspectRatio: ForwardRefExoticComponent<AspectRatioProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AspectRatioProps extends HTMLAttributes<HTMLDivElement> {
+    ratio?: number;
+}
+
+export declare type AttachCommit = {
+    tab: TabDescriptor;
+    sourceInstanceId: string;
+    insertIndex: number;
+};
+
+export declare const Autocomplete: AutocompleteCompound;
+
+declare const AutocompleteClear: ForwardRefExoticComponent<AutocompleteClearProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface AutocompleteClearProps extends Omit<ComponentPropsWithoutRef<typeof Autocomplete_2.Clear>, 'color'>, StyledComponentProps {
+}
+
+declare type AutocompleteCompound = typeof AutocompleteRoot & {
+    Root: typeof AutocompleteRoot;
+    Arrow: typeof Autocomplete_2.Arrow;
+    Backdrop: typeof Autocomplete_2.Backdrop;
+    Clear: typeof AutocompleteClear;
+    Collection: typeof Autocomplete_2.Collection;
+    Empty: typeof AutocompleteEmpty;
+    Group: typeof Autocomplete_2.Group;
+    GroupLabel: typeof AutocompleteGroupLabel;
+    Icon: typeof Autocomplete_2.Icon;
+    Input: typeof AutocompleteInput;
+    Item: typeof AutocompleteItem;
+    List: typeof AutocompleteList;
+    Popup: typeof AutocompletePopup;
+    Portal: typeof Autocomplete_2.Portal;
+    Positioner: typeof AutocompletePositioner;
+    Row: typeof Autocomplete_2.Row;
+    Separator: typeof AutocompleteSeparator;
+    Status: typeof Autocomplete_2.Status;
+    Trigger: typeof AutocompleteTrigger;
+    Value: typeof Autocomplete_2.Value;
+    useFilter: typeof Autocomplete_2.useFilter;
+    useFilteredItems: typeof Autocomplete_2.useFilteredItems;
+};
+
+declare const AutocompleteEmpty: ForwardRefExoticComponent<Omit<Omit<AutocompleteEmptyProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const AutocompleteGroupLabel: ForwardRefExoticComponent<Omit<Omit<AutocompleteGroupLabelProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const AutocompleteInput: ForwardRefExoticComponent<AutocompleteInputProps & RefAttributes<HTMLInputElement>>;
+
+export declare interface AutocompleteInputProps extends Omit<ComponentPropsWithoutRef<typeof Autocomplete_2.Input>, 'color' | 'size'>, StyledComponentProps {
+}
+
+declare const AutocompleteItem: ForwardRefExoticComponent<AutocompleteItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AutocompleteItemProps extends Omit<ComponentPropsWithoutRef<typeof Autocomplete_2.Item>, 'color'>, StyledComponentProps {
+}
+
+declare const AutocompleteList: ForwardRefExoticComponent<AutocompleteListProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AutocompleteListProps extends Omit<ComponentPropsWithoutRef<typeof Autocomplete_2.List>, 'color'>, StyledComponentProps {
+}
+
+declare const AutocompletePopup: ForwardRefExoticComponent<AutocompletePopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AutocompletePopupProps extends Omit<ComponentPropsWithoutRef<typeof Autocomplete_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const AutocompletePositioner: ForwardRefExoticComponent<Omit<Omit<AutocompletePositionerProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const AutocompleteRoot: {
+    ({ variant, color, size, ...props }: AutocompleteRootProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface AutocompleteRootProps extends Omit<ComponentPropsWithoutRef<typeof Autocomplete_2.Root>, 'color'>, StyledComponentProps {
+}
+
+declare const AutocompleteSeparator: ForwardRefExoticComponent<Omit<Omit<SeparatorProps_2, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const AutocompleteTrigger: ForwardRefExoticComponent<AutocompleteTriggerProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface AutocompleteTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Autocomplete_2.Trigger>, 'color'>, StyledComponentProps {
+}
+
+export declare const Avatar: AvatarCompound;
+
+declare const AvatarBase: ForwardRefExoticComponent<AvatarProps & RefAttributes<HTMLSpanElement>>;
+
+declare type AvatarCompound = typeof AvatarBase & {
+    Root: typeof AvatarRoot;
+    Image: typeof AvatarImage;
+    Fallback: typeof AvatarFallback;
+};
+
+declare const AvatarFallback: ForwardRefExoticComponent<AvatarFallbackProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface AvatarFallbackProps extends Omit<ComponentPropsWithoutRef<typeof Avatar_2.Fallback>, 'color'>, StyledComponentProps {
+}
+
+export declare const AvatarGroup: AvatarGroupCompound;
+
+declare type AvatarGroupCompound = typeof AvatarGroupRoot & {
+    Item: typeof AvatarGroupItem;
+};
+
+declare const AvatarGroupItem: ForwardRefExoticComponent<AvatarGroupItemProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface AvatarGroupItemProps extends Omit<AvatarProps, 'shape' | 'deterministic' | 'variant' | 'color' | 'size'>, StyledComponentProps {
+    shape?: AvatarShape;
+    deterministic?: boolean;
+}
+
+export declare type AvatarGroupOverlap = 'sm' | 'md' | 'lg';
+
+export declare interface AvatarGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+    shape?: AvatarShape;
+    deterministic?: boolean;
+    overlap?: AvatarGroupOverlap;
+    max?: number;
+    total?: number;
+}
+
+declare const AvatarGroupRoot: ForwardRefExoticComponent<AvatarGroupProps & RefAttributes<HTMLDivElement>>;
+
+declare const AvatarImage: ForwardRefExoticComponent<AvatarImageProps & RefAttributes<HTMLImageElement>>;
+
+export declare interface AvatarImageProps extends Omit<ComponentPropsWithoutRef<typeof Avatar_2.Image>, 'color'>, StyledComponentProps {
+}
+
+export declare interface AvatarProps extends AvatarRootProps {
+    src?: string;
+    alt?: string;
+    name?: string;
+    seed?: string;
+    fallback?: ReactNode;
+    fallbackIcon?: ReactNode;
+    imageProps?: Omit<AvatarImageProps, 'src' | 'alt'>;
+    fallbackProps?: Omit<AvatarFallbackProps, 'children'>;
+    children?: ReactNode;
+}
+
+declare const AvatarRoot: ForwardRefExoticComponent<AvatarRootProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface AvatarRootProps extends Omit<ComponentPropsWithoutRef<typeof Avatar_2.Root>, 'color'>, StyledComponentProps {
+    shape?: AvatarShape;
+    deterministic?: boolean;
+    paletteIndex?: number;
+}
+
+export declare type AvatarShape = 'circle' | 'rounded';
+
+export declare const Badge: ForwardRefExoticComponent<BadgeProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type BadgeColor = 'neutral' | 'brand' | 'success' | 'warning' | 'danger';
+
+export declare type BadgeOverlap = 'rectangular' | 'circular';
+
+export declare type BadgePosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+
+export declare interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color' | 'content'> {
+    content?: number | string;
+    variant?: BadgeVariant;
+    color?: BadgeColor;
+    position?: BadgePosition;
+    max?: number;
+    invisible?: boolean;
+    /** Pulsing animation for live indicators. */
+    pulse?: boolean;
+    /** Badge scale. */
+    size?: BadgeSize;
+    /** Adjusts positioning for circular children (e.g. avatars). */
+    overlap?: BadgeOverlap;
+    children: ReactNode;
+}
+
+export declare type BadgeSize = 'sm' | 'md' | 'lg';
+
+export declare type BadgeVariant = 'standard' | 'dot';
+
+export declare const Banner: BannerCompound;
+
+declare const BannerActions: ForwardRefExoticComponent<BannerActionsProps & RefAttributes<HTMLDivElement>>;
+
+export declare type BannerActionsProps = HTMLAttributes<HTMLDivElement>;
+
+declare const BannerClose: ForwardRefExoticComponent<BannerCloseProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface BannerCloseProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    'aria-label'?: string;
+}
+
+declare type BannerCompound = typeof BannerRoot & {
+    Icon: typeof BannerIcon;
+    Title: typeof BannerTitle;
+    Content: typeof BannerContent;
+    Actions: typeof BannerActions;
+    Close: typeof BannerClose;
+};
+
+declare const BannerContent: ForwardRefExoticComponent<BannerContentProps & RefAttributes<HTMLDivElement>>;
+
+export declare type BannerContentProps = HTMLAttributes<HTMLDivElement>;
+
+declare const BannerIcon: ForwardRefExoticComponent<BannerIconProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type BannerIconProps = HTMLAttributes<HTMLSpanElement>;
+
+export declare interface BannerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+}
+
+declare const BannerRoot: ForwardRefExoticComponent<BannerProps & RefAttributes<HTMLDivElement>>;
+
+declare const BannerTitle: ForwardRefExoticComponent<BannerTitleProps & RefAttributes<HTMLParagraphElement>>;
+
+export declare type BannerTitleProps = HTMLAttributes<HTMLParagraphElement>;
+
+export declare const BasicList: BasicListCompound;
+
+declare type BasicListCompound = typeof BasicListRoot & {
+    Root: typeof BasicListRoot;
+    Viewport: typeof List.Viewport;
+    Item: typeof BasicListItem;
+    ItemIcon: typeof List.ItemIcon;
+    ItemLabel: typeof List.ItemLabel;
+    ItemDescription: typeof List.ItemDescription;
+    ItemMeta: typeof List.ItemMeta;
+    ItemActions: typeof List.ItemActions;
+    ItemBadge: typeof BasicListItemBadge;
+    ItemChevron: typeof BasicListItemChevron;
+    Group: typeof List.Group;
+    GroupHeader: typeof List.GroupHeader;
+    Separator: typeof List.Separator;
+    Empty: typeof List.Empty;
+    Loading: typeof List.Loading;
+};
+
+declare const BasicListItem: ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLDivElement>>;
+
+declare const BasicListItemBadge: ForwardRefExoticComponent<BasicListItemBadgeProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type BasicListItemBadgeProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const BasicListItemChevron: ForwardRefExoticComponent<BasicListItemChevronProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type BasicListItemChevronProps = HTMLAttributes<HTMLSpanElement>;
+
+export declare type BasicListItemProps = ListItemProps;
+
+declare const BasicListRoot: ForwardRefExoticComponent<ListRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare type BasicListRootProps = ListRootProps;
+
+export declare const Blockquote: BlockquoteComponent;
+
+declare type BlockquoteComponent = <C extends BlockquoteElement = 'blockquote'>(props: BlockquoteProps<C> & {
+    ref?: PolymorphicRef<C>;
+}) => ReactElement | null;
+
+declare type BlockquoteElement = 'blockquote' | 'div';
+
+declare interface BlockquoteOwnProps extends TypographyBaseProps, TruncationProps {
+    variant?: BlockquoteVariant;
+}
+
+export declare type BlockquoteProps<C extends BlockquoteElement = BlockquoteElement> = PolymorphicComponentProps<C, BlockquoteOwnProps>;
+
+export declare type BlockquoteVariant = 'emphasis' | 'plain';
+
+export declare const Box: ForwardRefExoticComponent<BoxProps & RefAttributes<HTMLElement>>;
+
+export declare interface BoxProps extends HTMLAttributes<HTMLElement> {
+    as?: 'div' | 'span' | 'section' | 'article' | 'aside' | 'main' | 'nav' | 'header' | 'footer' | 'ul' | 'ol' | 'li';
+}
+
+declare type BreadcrumbItemBaseProps = {
+    /** Marks this item as the current page (not a link, styled differently). */
+    active?: boolean;
+};
+
+export declare type BreadcrumbItemProps = (BreadcrumbItemBaseProps & Omit<HTMLAttributes<HTMLElement>, 'color'> & {
+    href?: never;
+}) | (BreadcrumbItemBaseProps & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'color'> & {
+    href: string;
+    active?: false;
+});
+
+export declare const Breadcrumbs: BreadcrumbsCompound;
+
+declare type BreadcrumbsCompound = typeof BreadcrumbsRoot & {
+    Item: typeof BreadcrumbsItem;
+};
+
+declare const BreadcrumbsItem: ForwardRefExoticComponent<BreadcrumbItemProps & RefAttributes<HTMLElement>>;
+
+export declare interface BreadcrumbsProps extends HTMLAttributes<HTMLElement> {
+    /** Separator rendered between items. Defaults to a chevron right icon. */
+    separator?: ReactNode;
+    /** Maximum number of visible items before collapsing. Defaults to 8. */
+    maxItems?: number;
+    /** Number of items to show before the ellipsis. Defaults to 1. */
+    itemsBeforeCollapse?: number;
+    /** Number of items to show after the ellipsis. Defaults to 1. */
+    itemsAfterCollapse?: number;
+    /** Controls font size of the breadcrumb trail. */
+    size?: ComponentSize;
+}
+
+declare const BreadcrumbsRoot: ForwardRefExoticComponent<BreadcrumbsProps & RefAttributes<HTMLElement>>;
+
+export declare const Button: ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & RefAttributes<HTMLElement>>;
+
+export declare const ButtonGroup: ButtonGroupCompound;
+
+declare const ButtonGroupButton: ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & RefAttributes<HTMLElement>>;
+
+export declare type ButtonGroupButtonProps = ButtonProps;
+
+declare type ButtonGroupCompound = typeof ButtonGroupRoot & {
+    Button: typeof ButtonGroupButton;
+    IconButton: typeof ButtonGroupIconButton;
+};
+
+declare const ButtonGroupIconButton: ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & RefAttributes<HTMLElement>>;
+
+export declare type ButtonGroupIconButtonProps = IconButtonProps;
+
+export declare type ButtonGroupOrientation = 'horizontal' | 'vertical';
+
+export declare interface ButtonGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+    orientation?: ButtonGroupOrientation;
+    attached?: boolean;
+}
+
+declare const ButtonGroupRoot: ForwardRefExoticComponent<ButtonGroupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ButtonProps extends Button_2.Props, StyledComponentProps {
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+}
+
+export declare const Caption: <C extends CaptionElement = "span">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+declare type CaptionElement = 'span' | 'p' | 'div';
+
+export declare type CaptionProps<E extends CaptionElement = CaptionElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare const Card: CardCompound;
+
+declare const CardAction: ForwardRefExoticComponent<CardActionProps & RefAttributes<HTMLDivElement>>;
+
+declare const CardActionArea: ForwardRefExoticComponent<CardActionAreaProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface CardActionAreaProps extends HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+}
+
+export declare type CardActionProps = HTMLAttributes<HTMLDivElement>;
+
+declare const CardBody: ForwardRefExoticComponent<CardBodyProps & RefAttributes<HTMLDivElement>>;
+
+export declare type CardBodyProps = HTMLAttributes<HTMLDivElement>;
+
+declare type CardCompound = typeof CardRoot & {
+    Header: typeof CardHeader;
+    Title: typeof CardTitle;
+    Description: typeof CardDescription;
+    Body: typeof CardBody;
+    Footer: typeof CardFooter;
+    Action: typeof CardAction;
+    Eyebrow: typeof CardEyebrow;
+    Media: typeof CardMedia;
+    Cover: typeof CardCover;
+    Row: typeof CardRow;
+    Separator: typeof CardSeparator;
+    KeyValue: typeof CardKeyValue;
+    Stat: typeof CardStat;
+    Indicator: typeof CardIndicator;
+    ActionArea: typeof CardActionArea;
+    Toolbar: typeof CardToolbar;
+    Group: typeof CardGroup;
+};
+
+declare const CardCover: ForwardRefExoticComponent<CardCoverProps & RefAttributes<HTMLDivElement>>;
+
+export declare type CardCoverProps = HTMLAttributes<HTMLDivElement>;
+
+declare const CardDescription: ForwardRefExoticComponent<CardDescriptionProps & RefAttributes<HTMLParagraphElement>>;
+
+export declare type CardDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+
+declare const CardEyebrow: ForwardRefExoticComponent<CardEyebrowProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface CardEyebrowProps extends HTMLAttributes<HTMLSpanElement> {
+    mono?: boolean;
+}
+
+declare const CardFooter: ForwardRefExoticComponent<CardFooterProps & RefAttributes<HTMLDivElement>>;
+
+export declare type CardFooterProps = HTMLAttributes<HTMLDivElement>;
+
+declare const CardGroup: ForwardRefExoticComponent<CardGroupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface CardGroupProps extends HTMLAttributes<HTMLDivElement> {
+    columns?: number | 'auto';
+    gap?: 'sm' | 'md' | 'lg';
+}
+
+declare const CardHeader: ForwardRefExoticComponent<CardHeaderProps & RefAttributes<HTMLDivElement>>;
+
+export declare type CardHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+declare const CardIndicator: ForwardRefExoticComponent<CardIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface CardIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    status?: 'success' | 'warning' | 'danger' | 'neutral' | 'info';
+    pulse?: boolean;
+}
+
+declare const CardKeyValue: ForwardRefExoticComponent<CardKeyValueProps & RefAttributes<HTMLDListElement>>;
+
+export declare interface CardKeyValueProps extends HTMLAttributes<HTMLDListElement> {
+    label: ReactNode;
+    mono?: boolean;
+}
+
+declare const CardMedia: ForwardRefExoticComponent<CardMediaProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface CardMediaProps extends HTMLAttributes<HTMLDivElement> {
+    ratio?: number;
+}
+
+export declare interface CardProps extends Omit<HTMLAttributes<HTMLElement>, 'color'>, StyledComponentProps {
+    as?: 'section' | 'article' | 'div';
+    elevation?: SurfaceElevation;
+    surface?: SurfaceType;
+}
+
+declare const CardRoot: ForwardRefExoticComponent<CardProps & RefAttributes<HTMLElement>>;
+
+declare const CardRow: ForwardRefExoticComponent<CardRowProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface CardRowProps extends HTMLAttributes<HTMLDivElement> {
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    gap?: 'sm' | 'md' | 'lg';
+}
+
+declare const CardSeparator: ForwardRefExoticComponent<CardSeparatorProps & RefAttributes<HTMLDivElement>>;
+
+export declare type CardSeparatorProps = HTMLAttributes<HTMLDivElement>;
+
+declare const CardStat: ForwardRefExoticComponent<CardStatProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface CardStatProps extends HTMLAttributes<HTMLDivElement> {
+    mono?: boolean;
+}
+
+declare const CardTitle: ForwardRefExoticComponent<CardTitleProps & RefAttributes<HTMLHeadingElement>>;
+
+export declare type CardTitleProps = HTMLAttributes<HTMLHeadingElement>;
+
+declare const CardToolbar: ForwardRefExoticComponent<CardToolbarProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface CardToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Accessible name for the toolbar; provide via aria-label or aria-labelledby */
+    'aria-label'?: string;
+}
+
+export declare type CheckBehavior = 'checkbox' | 'radio';
+
+export declare const Checkbox: CheckboxCompound;
+
+declare type CheckboxCompound = typeof CheckboxItem & {
+    Root: typeof CheckboxRoot;
+    Control: typeof CheckboxControl;
+    Indicator: typeof CheckboxIndicator;
+    Label: typeof CheckboxLabel;
+    Description: typeof CheckboxDescription;
+    Item: typeof CheckboxItem;
+};
+
+declare const CheckboxControl: ForwardRefExoticComponent<CheckboxControlProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type CheckboxControlProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const CheckboxDescription: ForwardRefExoticComponent<CheckboxDescriptionProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type CheckboxDescriptionProps = HTMLAttributes<HTMLSpanElement>;
+
+export declare const CheckboxGroup: CheckboxGroupCompound;
+
+declare type CheckboxGroupCompound = typeof CheckboxGroupRoot & {
+    Item: typeof CheckboxGroupItem;
+};
+
+declare const CheckboxGroupItem: ForwardRefExoticComponent<CheckboxGroupItemProps & RefAttributes<HTMLElement>>;
+
+export declare interface CheckboxGroupItemProps extends Omit<CheckboxItemProps, 'variant' | 'color' | 'size' | 'value'>, StyledComponentProps {
+    value: string;
+}
+
+export declare interface CheckboxGroupProps extends Omit<ComponentPropsWithoutRef<typeof CheckboxGroup_2>, 'color'>, StyledComponentProps {
+    orientation?: 'vertical' | 'horizontal';
+}
+
+declare const CheckboxGroupRoot: ForwardRefExoticComponent<CheckboxGroupProps & RefAttributes<HTMLDivElement>>;
+
+declare const CheckboxIndicator: ForwardRefExoticComponent<CheckboxIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface CheckboxIndicatorProps extends Omit<ComponentPropsWithoutRef<typeof Checkbox_2.Indicator>, 'color'>, StyledComponentProps {
+}
+
+declare const CheckboxItem: ForwardRefExoticComponent<CheckboxItemProps & RefAttributes<HTMLElement>>;
+
+export declare interface CheckboxItemProps extends Omit<CheckboxRootProps, 'children'> {
+    children?: ReactNode;
+    description?: ReactNode;
+    indicator?: ReactNode;
+    keepIndicatorMounted?: boolean;
+    labelPosition?: 'start' | 'end';
+    layout?: 'inline' | 'spread';
+}
+
+declare const CheckboxLabel: ForwardRefExoticComponent<CheckboxLabelProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type CheckboxLabelProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const CheckboxRoot: ForwardRefExoticComponent<CheckboxRootProps & RefAttributes<HTMLElement>>;
+
+export declare interface CheckboxRootProps extends Omit<ComponentPropsWithoutRef<typeof Checkbox_2.Root>, 'color'>, StyledComponentProps {
+}
+
+export declare const Chip: ChipCompound;
+
+declare type ChipCompound = typeof ChipRoot & {
+    Group: typeof ChipGroup;
+    Item: typeof ChipItem;
+};
+
+declare const ChipGroup: ForwardRefExoticComponent<ChipGroupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ChipGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+    mono?: boolean;
+    clickable?: boolean;
+    /** Gap between chips. Default: 1 */
+    spacing?: Spacing;
+    /** Whether chips wrap to the next line. Default: true */
+    wrap?: boolean;
+}
+
+declare const ChipItem: ForwardRefExoticComponent<ChipProps & RefAttributes<HTMLElement>>;
+
+export declare interface ChipProps extends Omit<HTMLAttributes<HTMLElement>, 'color'>, StyledComponentProps {
+    as?: 'span' | 'div' | 'button';
+    mono?: boolean;
+    clickable?: boolean;
+    disabled?: boolean;
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+}
+
+declare const ChipRoot: ForwardRefExoticComponent<ChipProps & RefAttributes<HTMLElement>>;
+
+export declare const ClipboardText: ForwardRefExoticComponent<ClipboardTextProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface ClipboardTextProps extends HTMLAttributes<HTMLElement> {
+    /** The text to display and copy. */
+    value: string;
+    /** Use monospace font (default: false). */
+    mono?: boolean;
+    /** Truncate with ellipsis (default: false). */
+    truncate?: boolean;
+    /** Milliseconds to show success state (default: 1500). */
+    feedbackDuration?: number;
+}
+
+export declare const Code: <C extends CodeElement = "code">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+export declare function CodeBlock({ className, code, children, language, lineNumbers, copyable, wrap, maxHeight, onCopyCode, copyLabel, variant, color, size, ...props }: CodeBlockProps): JSX.Element;
+
+export declare namespace CodeBlock {
+    var displayName: string;
+}
+
+export declare interface CodeBlockProps extends Omit<HTMLAttributes<HTMLElement>, 'children' | 'color'>, StyledComponentProps {
+    code?: string;
+    children?: string;
+    language?: string;
+    lineNumbers?: boolean;
+    copyable?: boolean;
+    wrap?: boolean;
+    maxHeight?: number | string;
+    onCopyCode?: (value: string) => void;
+    copyLabel?: string;
+}
+
+declare type CodeElement = 'code' | 'span';
+
+export declare type CodeProps<E extends CodeElement = CodeElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare const Collapsible: ForwardRefExoticComponent<CollapsibleProps & RefAttributes<HTMLDivElement>>;
+
+export declare type CollapsibleAnimation = 'default' | 'fast' | 'none';
+
+export declare const CollapsibleContent: ForwardRefExoticComponent<CollapsibleContentProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface CollapsibleContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** Force mount even when collapsed (for SEO or pre-measuring) */
+    forceMount?: boolean;
+    children: ReactNode;
+}
+
+export declare interface CollapsibleContextValue {
+    open: boolean;
+    toggle: () => void;
+    disabled: boolean;
+}
+
+export declare interface CollapsibleProps extends HTMLAttributes<HTMLDivElement> {
+    /** Controlled open state */
+    open?: boolean;
+    /** Uncontrolled default open state (default: false) */
+    defaultOpen?: boolean;
+    /** Called when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Animation speed (default: 'default') */
+    animation?: CollapsibleAnimation;
+    /** Disable interaction */
+    disabled?: boolean;
+    children: ReactNode;
+}
+
+export declare const CollapsibleTrigger: ForwardRefExoticComponent<CollapsibleTriggerProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface CollapsibleTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+    children: ReactNode;
+}
+
+export declare interface ColumnDef {
+    /** Unique column identifier, used for Cell matching and sort callbacks */
+    id: string;
+    /** Header label */
+    header: ReactNode;
+    /** CSS grid column width — e.g. '1fr', '120px', 'minmax(80px, 1fr)' */
+    width?: string;
+    /** Column content alignment */
+    align?: 'start' | 'center' | 'end';
+    /** Whether this column is sortable */
+    sortable?: boolean;
+}
+
+export declare const Combobox: ComboboxCompound;
+
+declare const ComboboxChip: ForwardRefExoticComponent<ComboboxChipProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ComboboxChipProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.Chip>, 'color'>, StyledComponentProps {
+}
+
+declare const ComboboxChipRemove: ForwardRefExoticComponent<ComboboxChipRemoveProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface ComboboxChipRemoveProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.ChipRemove>, 'color'>, StyledComponentProps {
+}
+
+declare const ComboboxChips: ForwardRefExoticComponent<Omit<Omit<ComboboxChipsProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const ComboboxClear: ForwardRefExoticComponent<ComboboxClearProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface ComboboxClearProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.Clear>, 'color'>, StyledComponentProps {
+}
+
+declare type ComboboxCompound = typeof ComboboxRoot & {
+    Root: typeof ComboboxRoot;
+    Value: typeof Combobox_2.Value;
+    Input: typeof ComboboxInput;
+    Trigger: typeof ComboboxTrigger;
+    List: typeof ComboboxList;
+    Status: typeof Combobox_2.Status;
+    Portal: typeof Combobox_2.Portal;
+    Backdrop: typeof Combobox_2.Backdrop;
+    Positioner: typeof ComboboxPositioner;
+    Popup: typeof ComboboxPopup;
+    Arrow: typeof Combobox_2.Arrow;
+    Icon: typeof Combobox_2.Icon;
+    Group: typeof Combobox_2.Group;
+    GroupLabel: typeof ComboboxGroupLabel;
+    Item: typeof ComboboxItem;
+    ItemIndicator: typeof ComboboxItemIndicator;
+    Chips: typeof ComboboxChips;
+    Chip: typeof ComboboxChip;
+    ChipRemove: typeof ComboboxChipRemove;
+    Row: typeof Combobox_2.Row;
+    Collection: typeof Combobox_2.Collection;
+    Empty: typeof ComboboxEmpty;
+    Clear: typeof ComboboxClear;
+    Separator: typeof ComboboxSeparator;
+    useFilter: typeof Combobox_2.useFilter;
+    useFilteredItems: typeof Combobox_2.useFilteredItems;
+};
+
+declare const ComboboxEmpty: ForwardRefExoticComponent<Omit<Omit<AutocompleteEmptyProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const ComboboxGroupLabel: ForwardRefExoticComponent<Omit<Omit<AutocompleteGroupLabelProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const ComboboxInput: ForwardRefExoticComponent<ComboboxInputProps & RefAttributes<HTMLInputElement>>;
+
+export declare interface ComboboxInputProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.Input>, 'color' | 'size'>, StyledComponentProps {
+}
+
+declare const ComboboxItem: ForwardRefExoticComponent<ComboboxItemProps & RefAttributes<HTMLDivElement>>;
+
+declare const ComboboxItemIndicator: ForwardRefExoticComponent<Omit<Omit<ComboboxItemIndicatorProps, "ref"> & RefAttributes<HTMLSpanElement>, "ref"> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface ComboboxItemProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.Item>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps {
+}
+
+declare const ComboboxList: ForwardRefExoticComponent<ComboboxListProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ComboboxListProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.List>, 'color'>, StyledComponentProps {
+}
+
+declare const ComboboxPopup: ForwardRefExoticComponent<ComboboxPopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ComboboxPopupProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const ComboboxPositioner: ForwardRefExoticComponent<Omit<Omit<AutocompletePositionerProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare function ComboboxRoot<Value, Multiple extends boolean | undefined = false>({ variant, color, size, ...props }: ComboboxRootProps<Value, Multiple>): JSX.Element;
+
+declare namespace ComboboxRoot {
+    var displayName: string;
+}
+
+export declare type ComboboxRootProps<Value = unknown, Multiple extends boolean | undefined = false> = Omit<Combobox_2.Root.Props<Value, Multiple>, 'color'> & StyledComponentProps;
+
+declare const ComboboxSeparator: ForwardRefExoticComponent<Omit<Omit<SeparatorProps_2, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const ComboboxTrigger: ForwardRefExoticComponent<ComboboxTriggerProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface ComboboxTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Combobox_2.Trigger>, 'color'>, StyledComponentProps {
+}
+
+export declare interface CommandItemMeta {
+    key: Key_2;
+    isActive: boolean;
+    isDisabled: boolean;
+    groupKey?: string;
+    score?: number;
+    highlights?: HighlightRange[];
+}
+
+export declare const CommandList: CommandListCompound;
+
+declare interface CommandListActionsContextValue {
+    invoke: (key: Key_2) => void;
+    moveActive: (delta: number) => void;
+    setActiveKey: (key: Key_2 | null) => void;
+    setQuery: (query: string) => void;
+    dismiss: () => void;
+}
+
+declare type CommandListCompound = typeof CommandListRoot & {
+    Root: typeof CommandListRoot;
+    Input: typeof CommandListInput;
+    Results: typeof CommandListResults;
+    Item: typeof CommandListItem;
+    ItemIcon: typeof CommandListItemIcon;
+    ItemLabel: typeof CommandListItemLabel;
+    ItemDescription: typeof CommandListItemDescription;
+    ItemShortcut: typeof CommandListItemShortcut;
+    Empty: typeof CommandListEmpty;
+    Loading: typeof CommandListLoading;
+};
+
+declare interface CommandListConfigContextValue {
+    listId: string;
+    virtualized: boolean;
+    density: ListDensity_2;
+    loopFocus: boolean;
+    placeholder: string;
+    estimatedItemSize: number;
+    overscan: number;
+}
+
+declare const CommandListEmpty: ForwardRefExoticComponent<CommandListEmptyProps & RefAttributes<HTMLDivElement>>;
+
+declare interface CommandListEmptyProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+declare const CommandListInput: ForwardRefExoticComponent<CommandListInputProps & RefAttributes<HTMLInputElement>>;
+
+declare interface CommandListInputProps extends Omit<SearchInputProps, 'value' | 'onValueChange'> {
+    autoFocus?: boolean;
+}
+
+declare const CommandListItem: ForwardRefExoticComponent<CommandListItemProps & RefAttributes<HTMLDivElement>>;
+
+declare const CommandListItemDescription: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const CommandListItemIcon: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const CommandListItemLabel: ForwardRefExoticComponent<CommandListItemLabelProps & RefAttributes<HTMLSpanElement>>;
+
+declare interface CommandListItemLabelProps extends HTMLAttributes<HTMLSpanElement> {
+    highlights?: HighlightRange[];
+}
+
+export declare interface CommandListItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    itemKey: Key_2;
+    disabled?: boolean;
+    children: ReactNode;
+}
+
+declare const CommandListItemShortcut: ForwardRefExoticComponent<CommandListItemShortcutProps & RefAttributes<HTMLSpanElement>>;
+
+declare interface CommandListItemShortcutProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Pre-split key labels. If omitted, children string is auto-split. */
+    keys?: string[];
+}
+
+export declare interface CommandListItemState {
+    isActive: boolean;
+    isDisabled: boolean;
+}
+
+declare const CommandListLoading: ForwardRefExoticComponent<CommandListLoadingProps & RefAttributes<HTMLDivElement>>;
+
+declare interface CommandListLoadingProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+declare const CommandListResults: ForwardRefExoticComponent<CommandListResultsProps & RefAttributes<HTMLDivElement>>;
+
+declare type CommandListResultsProps = HTMLAttributes<HTMLDivElement>;
+
+declare const CommandListRoot: <TItem>(props: CommandListRootProps<TItem> & {
+    ref?: Ref<HTMLDivElement>;
+}) => ReactNode;
+
+export declare interface CommandListRootProps<TItem = unknown> extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+    /** Items to display. For external search, update this when results arrive. */
+    items: readonly TItem[];
+    itemKey: (item: TItem) => Key_2;
+    /** Extract display label for client-side filtering and highlight rendering. */
+    getTextValue?: (item: TItem) => string;
+    /** Render a single command item. */
+    renderItem: (item: TItem, meta: CommandItemMeta) => ReactNode;
+    query?: string;
+    defaultQuery?: string;
+    onQueryChange?: (query: string) => void;
+    /** Return `true`/`false` for include/exclude, or a number for scored ranking. */
+    filterFn?: (item: TItem, query: string) => boolean | number;
+    /** Sort filtered results by score. Default true when filterFn returns numbers. */
+    sortByScore?: boolean;
+    groupBy?: (item: TItem) => string;
+    groupOrder?: readonly string[];
+    groupLabel?: (groupKey: string) => string;
+    highlights?: ReadonlyMap<Key_2, HighlightRange[]>;
+    disabledKeys?: Iterable<Key_2>;
+    onAction?: (key: Key_2, item: TItem) => void;
+    onDismiss?: () => void;
+    loading?: boolean;
+    density?: ListDensity_2;
+    loopFocus?: boolean;
+    placeholder?: string;
+    virtualized?: boolean;
+    overscan?: number;
+    estimatedItemSize?: number;
+    children?: ReactNode;
+}
+
+declare interface CommandListStore {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => CommandListStoreSnapshot;
+    getItemState: (key: Key_2) => CommandListItemState;
+    setActiveIndex: (index: number) => void;
+    setActiveKey: (key: Key_2 | null) => void;
+    setQuery: (query: string, silent?: boolean) => void;
+    setItems: (items: ProcessedItem[], silent?: boolean) => void;
+    setLoading: (loading: boolean, silent?: boolean) => void;
+    getItems: () => readonly ProcessedItem[];
+    getItemByIndex: (index: number) => ProcessedItem | undefined;
+    /** Rebuild snapshot and notify listeners. Call from useEffect after silent updates. */
+    emit: () => void;
+}
+
+declare interface CommandListStoreSnapshot {
+    activeIndex: number;
+    activeKey: Key_2 | null;
+    query: string;
+    visibleCount: number;
+    loading: boolean;
+}
+
+export declare type ComponentColor = 'neutral' | 'brand' | 'success' | 'warning' | 'danger' | 'info';
+
+export declare type ComponentSize = 'sm' | 'md' | 'lg';
+
+export declare type ComponentVariant = 'solid' | 'soft' | 'outline' | 'ghost';
+
+export declare function computeTabSegments(tabs: TabDescriptor[], groups?: TabGroupDescriptor[]): TabSegments;
+
+export declare const ConfirmButton: ForwardRefExoticComponent<ConfirmButtonProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface ConfirmButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'color' | 'onClick' | 'type'>, StyledComponentProps {
+    /** Text shown in the confirm state. */
+    confirmLabel?: string;
+    /** Color applied in the confirm state. */
+    confirmColor?: ComponentColor;
+    /** Milliseconds before the confirm state reverts to default. */
+    confirmTimeout?: number;
+    /** Callback fired on the second (confirming) click. */
+    onConfirm: () => void;
+    /** Whether the button is disabled. */
+    disabled?: boolean;
+    children: ReactNode;
+}
+
+export declare const Container: ForwardRefExoticComponent<ContainerProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ContainerMaxWidth = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+
+export declare interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
+    maxWidth?: ContainerMaxWidth;
+    disableGutters?: boolean;
+    fixed?: boolean;
+}
+
+declare const Content: ForwardRefExoticComponent<AppShellContentProps & RefAttributes<HTMLElement>>;
+
+export declare const ContextMenu: ContextMenuCompound;
+
+declare const ContextMenuBackdrop: ForwardRefExoticComponent<Omit<Omit<ContextMenuBackdropProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const ContextMenuCheckboxItem: ForwardRefExoticComponent<ContextMenuCheckboxItemProps & RefAttributes<HTMLElement>>;
+
+declare const ContextMenuCheckboxItemIndicator: ForwardRefExoticComponent<Omit<Omit<ContextMenuCheckboxItemIndicatorProps, "ref"> & RefAttributes<HTMLSpanElement>, "ref"> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface ContextMenuCheckboxItemProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.CheckboxItem>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_2 {
+}
+
+declare type ContextMenuCompound = typeof ContextMenuRoot & {
+    Root: typeof ContextMenuRoot;
+    Trigger: typeof ContextMenuTrigger;
+    Portal: typeof ContextMenu_2.Portal;
+    Backdrop: typeof ContextMenuBackdrop;
+    Positioner: typeof ContextMenuPositioner;
+    Popup: typeof ContextMenuPopup;
+    Arrow: typeof ContextMenu_2.Arrow;
+    Group: typeof ContextMenu_2.Group;
+    GroupLabel: typeof ContextMenuGroupLabel;
+    Item: typeof ContextMenuItem;
+    LinkItem: typeof ContextMenuLinkItem;
+    CheckboxItem: typeof ContextMenuCheckboxItem;
+    CheckboxItemIndicator: typeof ContextMenuCheckboxItemIndicator;
+    RadioGroup: typeof ContextMenu_2.RadioGroup;
+    RadioItem: typeof ContextMenuRadioItem;
+    RadioItemIndicator: typeof ContextMenuRadioItemIndicator;
+    SubmenuRoot: typeof ContextMenu_2.SubmenuRoot;
+    SubmenuTrigger: typeof ContextMenuSubmenuTrigger;
+    Separator: typeof ContextMenuSeparator;
+};
+
+declare const ContextMenuGroupLabel: ForwardRefExoticComponent<Omit<Omit<Omit<ContextMenuGroupLabelProps, "ref"> & RefAttributes<HTMLDivElement>, "ref">, "color"> & StyledComponentProps & RefAttributes<HTMLDivElement>>;
+
+declare const ContextMenuItem: ForwardRefExoticComponent<ContextMenuItemProps & RefAttributes<HTMLElement>>;
+
+export declare interface ContextMenuItemProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.Item>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_2 {
+}
+
+declare const ContextMenuLinkItem: ForwardRefExoticComponent<ContextMenuLinkItemProps & RefAttributes<Element>>;
+
+export declare interface ContextMenuLinkItemProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.LinkItem>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_2 {
+}
+
+declare const ContextMenuPopup: ForwardRefExoticComponent<ContextMenuPopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ContextMenuPopupProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const ContextMenuPositioner: ForwardRefExoticComponent<Omit<Omit<ContextMenuPositionerProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const ContextMenuRadioItem: ForwardRefExoticComponent<ContextMenuRadioItemProps & RefAttributes<HTMLElement>>;
+
+declare const ContextMenuRadioItemIndicator: ForwardRefExoticComponent<Omit<Omit<ContextMenuRadioItemIndicatorProps, "ref"> & RefAttributes<HTMLSpanElement>, "ref"> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface ContextMenuRadioItemProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.RadioItem>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_2 {
+}
+
+declare const ContextMenuRoot: {
+    ({ variant, color, size, ...props }: ContextMenuRootProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface ContextMenuRootProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.Root>, 'color'>, StyledComponentProps {
+}
+
+declare const ContextMenuSeparator: ForwardRefExoticComponent<Omit<Omit<Omit<SeparatorProps_2, "ref"> & RefAttributes<HTMLDivElement>, "ref">, "color"> & StyledComponentProps & RefAttributes<HTMLDivElement>>;
+
+declare const ContextMenuSubmenuTrigger: ForwardRefExoticComponent<ContextMenuSubmenuTriggerProps & RefAttributes<HTMLElement>>;
+
+export declare interface ContextMenuSubmenuTriggerProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.SubmenuTrigger>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_2 {
+    showCaret?: boolean;
+}
+
+declare const ContextMenuTrigger: ForwardRefExoticComponent<ContextMenuTriggerProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ContextMenuTriggerProps extends Omit<ComponentPropsWithoutRef<typeof ContextMenu_2.Trigger>, 'color'>, StyledComponentProps {
+}
+
+export declare const DataTable: DataTableCompound;
+
+declare const DataTableBody: ForwardRefExoticComponent<DataTableBodyProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare interface DataTableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
+    renderExpandedRow?: (row: unknown) => ReactNode;
+}
+
+declare const DataTableColumnVisibility: ForwardRefExoticComponent<DataTableColumnVisibilityProps & RefAttributes<HTMLDivElement>>;
+
+export declare type DataTableColumnVisibilityProps = HTMLAttributes<HTMLDivElement>;
+
+declare type DataTableCompound = typeof DataTableRoot & {
+    Root: typeof DataTableRoot;
+    Container: typeof DataTableContainer;
+    Header: typeof DataTableHeader;
+    Body: typeof DataTableBody;
+    VirtualBody: typeof DataTableVirtualBody;
+    Footer: typeof DataTableFooter;
+    Toolbar: typeof DataTableToolbar;
+    ColumnVisibility: typeof DataTableColumnVisibility;
+    Pagination: typeof DataTablePagination;
+    Empty: typeof DataTableEmpty;
+    Loading: typeof DataTableLoading;
+};
+
+declare const DataTableContainer: ForwardRefExoticComponent<DataTableContainerProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface DataTableContainerProps extends HTMLAttributes<HTMLDivElement> {
+    height?: number | string;
+    maxHeight?: number | string;
+}
+
+declare interface DataTableContextValue {
+    table: Table_2<any>;
+    features: DataTableFeatures;
+    stickyHeader: boolean;
+    hoverable: boolean;
+    striped: boolean;
+}
+
+declare const DataTableEmpty: ForwardRefExoticComponent<DataTableEmptyProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface DataTableEmptyProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: ReactNode;
+    title?: string;
+    description?: string;
+}
+
+export declare interface DataTableFeatures {
+    sorting?: boolean;
+    filtering?: boolean;
+    globalFilter?: boolean;
+    columnResizing?: boolean;
+    columnOrdering?: boolean;
+    columnPinning?: boolean;
+    columnVisibility?: boolean;
+    rowSelection?: false | 'single' | 'multi';
+    rowExpansion?: boolean;
+    pagination?: boolean;
+}
+
+declare const DataTableFooter: ForwardRefExoticComponent<DataTableFooterProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare type DataTableFooterProps = HTMLAttributes<HTMLTableSectionElement>;
+
+declare const DataTableHeader: ForwardRefExoticComponent<DataTableHeaderProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare type DataTableHeaderProps = HTMLAttributes<HTMLTableSectionElement>;
+
+declare const DataTableLoading: ForwardRefExoticComponent<DataTableLoadingProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare interface DataTableLoadingProps extends HTMLAttributes<HTMLTableSectionElement> {
+    rows?: number;
+}
+
+declare const DataTablePagination: ForwardRefExoticComponent<DataTablePaginationProps & RefAttributes<HTMLDivElement>>;
+
+export declare type DataTablePaginationProps = HTMLAttributes<HTMLDivElement>;
+
+declare const DataTableRoot: ForwardRefExoticComponent<DataTableRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface DataTableRootProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+    table: Table_2<any>;
+    features?: DataTableFeatures;
+    stickyHeader?: boolean;
+    hoverable?: boolean;
+    striped?: boolean;
+}
+
+declare const DataTableToolbar: ForwardRefExoticComponent<DataTableToolbarProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface DataTableToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    searchPlaceholder?: string;
+}
+
+declare const DataTableVirtualBody: ForwardRefExoticComponent<DataTableVirtualBodyProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare interface DataTableVirtualBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
+    estimateRowSize?: number;
+    overscan?: number;
+    /**
+     * When true, skips dynamic row measurement via `getBoundingClientRect`.
+     * Use this when all rows have the same height (set via `estimateRowSize`)
+     * to avoid forced reflow on mount — a significant perf win for large tables.
+     */
+    fixedRowHeight?: boolean;
+}
+
+declare interface DebouncedFunction<TArgs extends unknown[], TReturn> {
+    (...args: TArgs): void;
+    cancel: () => void;
+    flush: () => TReturn | undefined;
+}
+
+declare interface DecoratedContentProps {
+    children?: ReactNode;
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+}
+
+declare interface DecoratedContentProps_2 {
+    children?: ReactNode;
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+}
+
+declare interface DecoratedContentProps_3 {
+    children?: ReactNode;
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+}
+
+declare interface DecoratedContentProps_4 {
+    children?: ReactNode;
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+}
+
+export declare const DescriptionList: DescriptionListCompound;
+
+export declare type DescriptionListColumns = 1 | 2 | 3;
+
+declare type DescriptionListCompound = typeof DescriptionListRoot & {
+    Item: typeof DescriptionListItem;
+};
+
+declare const DescriptionListItem: ForwardRefExoticComponent<DescriptionListItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface DescriptionListItemProps extends HTMLAttributes<HTMLDivElement> {
+    label: string;
+    copyable?: boolean;
+    children?: ReactNode;
+}
+
+export declare type DescriptionListLayout = 'horizontal' | 'vertical' | 'grid';
+
+export declare interface DescriptionListProps extends HTMLAttributes<HTMLDListElement> {
+    layout?: DescriptionListLayout;
+    columns?: DescriptionListColumns;
+    size?: 'sm' | 'md' | 'lg';
+}
+
+declare const DescriptionListRoot: ForwardRefExoticComponent<DescriptionListProps & RefAttributes<HTMLDListElement>>;
+
+export declare type DetachCommit = {
+    id: TabId;
+    payload?: unknown;
+    screenX: number;
+    screenY: number;
+};
+
+export declare const Dialog: DialogCompound;
+
+declare const DialogBody: ForwardRefExoticComponent<DialogBodyProps & RefAttributes<HTMLDivElement>>;
+
+export declare type DialogBodyProps = HTMLAttributes<HTMLDivElement>;
+
+declare const DialogClose: ForwardRefExoticComponent<DialogCloseProps & RefAttributes<HTMLButtonElement>>;
+
+export declare type DialogCloseProps = HTMLAttributes<HTMLButtonElement>;
+
+declare type DialogCompound = typeof DialogRoot & {
+    Title: typeof DialogTitle;
+    Body: typeof DialogBody;
+    Footer: typeof DialogFooter;
+    Close: typeof DialogClose;
+};
+
+declare const DialogFooter: ForwardRefExoticComponent<DialogFooterProps & RefAttributes<HTMLDivElement>>;
+
+export declare type DialogFooterProps = HTMLAttributes<HTMLDivElement>;
+
+export declare interface DialogProps extends HTMLAttributes<HTMLDivElement> {
+    open: boolean;
+    onClose: () => void;
+    size?: DialogSize;
+}
+
+declare const DialogRoot: ForwardRefExoticComponent<DialogProps & RefAttributes<HTMLDivElement>>;
+
+export declare type DialogSize = 'sm' | 'md' | 'lg' | 'xl';
+
+declare const DialogTitle: ForwardRefExoticComponent<DialogTitleProps & RefAttributes<HTMLHeadingElement>>;
+
+export declare interface DialogTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+    icon?: ReactNode;
+}
+
+export declare type DockDirection = 'horizontal' | 'vertical';
+
+export declare const DockLayout: ForwardRefExoticComponent<DockLayoutProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface DockLayoutProps extends HTMLAttributes<HTMLDivElement> {
+    /** The layout tree definition. */
+    layout: DockNode;
+    /** Callback when layout changes (tab switches, closes, resize). */
+    onLayoutChange?: (layout: DockNode) => void;
+}
+
+export declare interface DockLeaf {
+    type: 'leaf';
+    id: string;
+    tabs: DockTab[];
+    activeTab?: string;
+}
+
+export declare type DockNode = DockSplit | DockLeaf;
+
+export declare interface DockSplit {
+    type: 'split';
+    direction: DockDirection;
+    children: DockNode[];
+    sizes?: number[];
+}
+
+export declare interface DockTab {
+    id: string;
+    title: string;
+    icon?: ReactNode;
+    closable?: boolean;
+    content: ReactNode;
+}
+
+export declare type DragMode = 'idle' | 'reorder' | 'detach-armed';
+
+export declare const Drawer: DrawerCompound;
+
+export declare type DrawerAnchor = 'left' | 'right' | 'top' | 'bottom';
+
+declare type DrawerCompound = typeof DrawerRoot & {
+    Content: typeof DrawerContent;
+};
+
+declare const DrawerContent: ForwardRefExoticComponent<DrawerContentProps & RefAttributes<HTMLDivElement>>;
+
+export declare type DrawerContentProps = HTMLAttributes<HTMLDivElement>;
+
+export declare type DrawerHandleVariant = 'bar' | 'edge';
+
+export declare interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    open: boolean;
+    onOpenChange?: (open: boolean) => void;
+    anchor?: DrawerAnchor;
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    resizable?: boolean;
+    handleVariant?: DrawerHandleVariant;
+    overlay?: boolean;
+    modal?: boolean;
+    animate?: boolean;
+    onSizeChange?: (size: number) => void;
+    children?: ReactNode;
+}
+
+declare const DrawerRoot: ForwardRefExoticComponent<DrawerProps & RefAttributes<HTMLDivElement>>;
+
+declare interface DropZoneRegistration {
+    instanceId: string;
+    getRect: () => DOMRect | null;
+    getElement: () => HTMLElement | null;
+    onAttach: (commit: AttachCommit) => void;
+}
+
+export declare const EditableList: EditableListCompound;
+
+declare type EditableListCompound = typeof EditableListRoot & {
+    Root: typeof EditableListRoot;
+    Viewport: typeof List.Viewport;
+    Item: typeof EditableListItem;
+    ItemView: typeof EditableListItemView;
+    ItemEditor: typeof EditableListItemEditor;
+    ItemField: typeof EditableListItemField;
+    ItemSave: typeof EditableListItemSave;
+    ItemCancel: typeof EditableListItemCancel;
+    useField: typeof useEditableField;
+    ItemIcon: typeof List.ItemIcon;
+    ItemLabel: typeof List.ItemLabel;
+    ItemDescription: typeof List.ItemDescription;
+    ItemMeta: typeof List.ItemMeta;
+    ItemActions: typeof List.ItemActions;
+    Group: typeof List.Group;
+    GroupHeader: typeof List.GroupHeader;
+    Separator: typeof List.Separator;
+    Empty: typeof List.Empty;
+    Loading: typeof List.Loading;
+};
+
+declare const EditableListItem: ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLDivElement>>;
+
+declare const EditableListItemCancel: ForwardRefExoticComponent<EditableListItemCancelProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface EditableListItemCancelProps extends HTMLAttributes<HTMLButtonElement> {
+    children?: ReactNode;
+}
+
+declare const EditableListItemEditor: ForwardRefExoticComponent<EditableListItemEditorProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface EditableListItemEditorProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+declare const EditableListItemField: ForwardRefExoticComponent<EditableListItemFieldProps & RefAttributes<HTMLInputElement>>;
+
+export declare interface EditableListItemFieldProps {
+    /** Field name, used as key in the values map passed to onCommit */
+    name: string;
+    /** Default value when entering edit mode */
+    defaultValue?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether this field should auto-focus when edit mode starts */
+    autoFocus?: boolean;
+    /** Change handler */
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    /** Additional class name */
+    className?: string;
+}
+
+export declare type EditableListItemProps = ListItemProps;
+
+declare const EditableListItemSave: ForwardRefExoticComponent<EditableListItemSaveProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface EditableListItemSaveProps extends HTMLAttributes<HTMLButtonElement> {
+    children?: ReactNode;
+}
+
+declare const EditableListItemView: ForwardRefExoticComponent<EditableListItemViewProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface EditableListItemViewProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+declare const EditableListRoot: ForwardRefExoticComponent<EditableListRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface EditableListRootProps extends ListRootProps {
+    /** Currently editing item key (controlled) */
+    editingKey?: Key | null;
+    /** Initial editing key (uncontrolled) */
+    defaultEditingKey?: Key | null;
+    /** Callback when editing key changes */
+    onEditingKeyChange?: (key: Key | null) => void;
+    /** Called when user commits an edit (Enter or Save button) */
+    onCommit?: (key: Key, values: Record<string, string>) => void;
+    /** Called when user cancels editing (Escape or Cancel button) */
+    onCancel?: (key: Key) => void;
+    /** Validation function, called before onCommit */
+    validateItem?: ValidateItem;
+    /** Whether editing is allowed (global toggle for read-only mode) */
+    editable?: boolean;
+}
+
+declare const EditorTabCloseButton: ForwardRefExoticComponent<EditorTabCloseButtonProps & RefAttributes<HTMLButtonElement>>;
+
+declare interface EditorTabCloseButtonProps {
+    tabId: string;
+    tabTitle: string;
+    dirty?: boolean;
+    onClose: (id: string) => void;
+    className?: string;
+}
+
+declare const EditorTabGroupChip: ForwardRefExoticComponent<EditorTabGroupChipProps & RefAttributes<HTMLElement>>;
+
+declare interface EditorTabGroupChipProps {
+    group: TabGroupDescriptor;
+    tabCount: number;
+    className?: string;
+}
+
+declare const EditorTabItem: NamedExoticComponent<EditorTabItemProps & RefAttributes<HTMLDivElement>>;
+
+declare interface EditorTabItemProps {
+    tab: TabDescriptor;
+    className?: string;
+}
+
+export declare const EditorTabs: EditorTabsCompound;
+
+declare type EditorTabsCompound = typeof EditorTabsRoot & {
+    Root: typeof EditorTabsRoot;
+    Viewport: typeof EditorTabsViewport;
+    Segment: typeof EditorTabsSegment;
+    Item: typeof EditorTabItem;
+    CloseButton: typeof EditorTabCloseButton;
+    ScrollButton: typeof EditorTabScrollButton;
+    ScrollShadow: typeof EditorTabScrollShadow;
+    GroupChip: typeof EditorTabGroupChip;
+};
+
+declare interface EditorTabsContextValue {
+    activeId: TabId;
+    onActiveChange: (id: TabId) => void;
+    onCloseTab?: (id: TabId) => void;
+    onContextMenuTab?: (id: TabId, ev: React.MouseEvent) => void;
+    onToggleGroupCollapsed?: (groupId: TabGroupId) => void;
+    onGroupContextMenu?: (groupId: TabGroupId, ev: React.MouseEvent) => void;
+    scrollState: ScrollState;
+    scrollTo: (direction: 'left' | 'right') => void;
+    viewportRef: React.RefObject<HTMLDivElement | null>;
+    tabs: TabId[];
+    dragActiveId: TabId | null;
+    dragMode: DragMode;
+    isAttachDropTarget: boolean;
+    attachInsertIndex: number | null;
+}
+
+declare const EditorTabScrollButton: ForwardRefExoticComponent<EditorTabScrollButtonProps & RefAttributes<HTMLButtonElement>>;
+
+declare interface EditorTabScrollButtonProps {
+    direction: 'left' | 'right';
+    className?: string;
+}
+
+declare const EditorTabScrollShadow: ForwardRefExoticComponent<EditorTabScrollShadowProps & RefAttributes<HTMLDivElement>>;
+
+declare interface EditorTabScrollShadowProps {
+    side: 'left' | 'right';
+    className?: string;
+}
+
+export declare interface EditorTabsProps extends Omit<StyledComponentProps, 'variant'> {
+    /** Tab style variant. `'pill'` gives rounded top corners for browser-style tabs. */
+    variant?: StyledComponentProps['variant'] | 'pill';
+    tabs: TabDescriptor[];
+    groups?: TabGroupDescriptor[];
+    activeId?: TabId;
+    defaultActiveId?: TabId;
+    onActiveChange?: (id: TabId) => void;
+    onCloseTab?: (id: TabId) => void;
+    onContextMenuTab?: (id: TabId, ev: React.MouseEvent) => void;
+    onToggleGroupCollapsed?: (groupId: TabGroupId) => void;
+    onGroupContextMenu?: (groupId: TabGroupId, ev: React.MouseEvent) => void;
+    onReorder?: (nextTabs: TabDescriptor[], meta: ReorderMeta) => void;
+    allowReorderAcrossPinnedBoundary?: boolean;
+    allowReorderAcrossGroups?: boolean;
+    detachable?: boolean;
+    detachThresholdPx?: number;
+    onDetachCommit?: (commit: DetachCommit) => void;
+    instanceId?: string;
+    onAttachTab?: (commit: AttachCommit) => void;
+    /** When true and a TabDragBrokerProvider is present, vertical detach starts a
+     *  broker session instead of the default Phase 3 flow. */
+    detachToBroker?: boolean;
+    className?: string;
+}
+
+declare const EditorTabsRoot: ForwardRefExoticComponent<EditorTabsProps & RefAttributes<HTMLDivElement>>;
+
+declare const EditorTabsSegment: ForwardRefExoticComponent<EditorTabsSegmentProps & RefAttributes<HTMLDivElement>>;
+
+declare interface EditorTabsSegmentProps {
+    type: 'pinned' | 'group' | 'ungrouped';
+    group?: TabGroupDescriptor;
+    tabCount?: number;
+    items?: string[];
+    children: ReactNode;
+    className?: string;
+}
+
+declare const EditorTabsViewport: ForwardRefExoticComponent<EditorTabsViewportProps & RefAttributes<HTMLDivElement>>;
+
+declare interface EditorTabsViewportProps {
+    children: ReactNode;
+    className?: string;
+}
+
+export declare const Em: <C extends EmElement = "em">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+declare type EmElement = 'em' | 'span';
+
+export declare type EmProps<E extends EmElement = EmElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare const EmptyState: ForwardRefExoticComponent<EmptyStateProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface EmptyStateProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: ReactNode;
+    title: string;
+    description?: string;
+    action?: ReactNode;
+    size?: 'sm' | 'md' | 'lg';
+}
+
+/** Any element that has a string `.value` and can receive focus. */
+export declare interface FieldElement {
+    value: string;
+    focus: () => void;
+    select?: () => void;
+}
+
+/** Per-field error message keyed by field name */
+export declare type FieldErrors = Record<string, string | undefined>;
+
+export declare const FileTable: FileTableCompound;
+
+export declare function FileTableBody({ rowActions }: FileTableBodyProps): JSX.Element;
+
+export declare interface FileTableBodyProps {
+    rowActions?: (item: FileTableItem) => ReactNode;
+}
+
+export declare function FileTableColumn<T extends FileTableItem = FileTableItem>(_props: FileTableColumnProps<T>): null;
+
+export declare namespace FileTableColumn {
+    var displayName: string;
+}
+
+export declare interface FileTableColumnProps<T extends FileTableItem = FileTableItem> {
+    id: string;
+    header: ReactNode;
+    accessor: (item: T) => ReactNode;
+    sortAccessor?: (item: T) => string | number | Date | undefined;
+    sortFn?: (a: T, b: T) => number;
+    width?: number | string;
+    sortable?: boolean;
+    mono?: boolean;
+    align?: 'left' | 'right';
+}
+
+declare type FileTableCompound = typeof FileTableRoot & {
+    Root: typeof FileTableRoot;
+    Header: typeof FileTableHeader;
+    Body: typeof FileTableBody;
+    Status: typeof FileTableStatus;
+    Column: typeof FileTableColumn;
+};
+
+export declare function FileTableHeader({ children }: FileTableHeaderProps): JSX.Element;
+
+export declare interface FileTableHeaderProps {
+    children?: ReactNode;
+}
+
+export declare interface FileTableItem {
+    id: string;
+    name: string;
+    type: 'file' | 'folder';
+    size?: number;
+    modified?: string;
+    extension?: string;
+    children?: FileTableItem[];
+}
+
+export declare const FileTableRoot: ForwardRefExoticComponent<FileTableRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface FileTableRootProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    items: FileTableItem[];
+    onNavigate?: (folder: FileTableItem) => void;
+    onSelect?: (item: FileTableItem) => void;
+    selectedId?: string;
+    showParent?: boolean;
+    onNavigateUp?: () => void;
+    defaultSort?: SortConfig;
+    children: ReactNode;
+}
+
+export declare function FileTableStatus(): JSX.Element;
+
+/** Derive file type label from a file node */
+export declare function fileTypeLabel(node: {
+    type: string;
+    extension?: string;
+}): string;
+
+export declare const FilterBar: FilterBarCompound;
+
+declare const FilterBarAdd: ForwardRefExoticComponent<FilterBarAddProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface FilterBarAddProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+    onClick?: () => void;
+    children?: ReactNode;
+}
+
+declare const FilterBarChip: ForwardRefExoticComponent<FilterBarChipProps & RefAttributes<HTMLElement>>;
+
+export declare interface FilterBarChipProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    onRemove?: () => void;
+    children: ReactNode;
+}
+
+declare const FilterBarClear: ForwardRefExoticComponent<FilterBarClearProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface FilterBarClearProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+    onClick: () => void;
+    children?: ReactNode;
+}
+
+declare type FilterBarCompound = typeof FilterBarRoot & {
+    Chip: typeof FilterBarChip;
+    Add: typeof FilterBarAdd;
+    Clear: typeof FilterBarClear;
+};
+
+export declare interface FilterBarProps extends HTMLAttributes<HTMLDivElement> {
+    size?: ComponentSize;
+}
+
+declare const FilterBarRoot: ForwardRefExoticComponent<FilterBarProps & RefAttributes<HTMLDivElement>>;
+
+export declare const FindBar: ForwardRefExoticComponent<FindBarProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface FindBarProps extends HTMLAttributes<HTMLDivElement> {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    query?: string;
+    onQueryChange?: (query: string) => void;
+    matchCount?: number;
+    currentMatch?: number;
+    onNext?: () => void;
+    onPrevious?: () => void;
+    replaceEnabled?: boolean;
+    replaceText?: string;
+    onReplaceTextChange?: (text: string) => void;
+    onReplace?: () => void;
+    onReplaceAll?: () => void;
+    caseSensitive?: boolean;
+    onCaseSensitiveChange?: (v: boolean) => void;
+    regex?: boolean;
+    onRegexChange?: (v: boolean) => void;
+    wholeWord?: boolean;
+    onWholeWordChange?: (v: boolean) => void;
+}
+
+export declare interface FlatNode<TItem = unknown> {
+    key: Key_3;
+    item: TItem;
+    depth: number;
+    parentKey: Key_3 | null;
+    isBranch: boolean;
+    isLastChild: boolean;
+    ancestorIsLast: boolean[];
+}
+
+declare const Footer: ForwardRefExoticComponent<AppShellFooterProps & RefAttributes<HTMLElement>>;
+
+/** Format bytes to human-readable string */
+export declare function formatBytes(bytes: number): string;
+
+/** Format ISO date to short date string */
+export declare function formatDate(iso: string): string;
+
+export declare const FormField: ForwardRefExoticComponent<FormFieldProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface FormFieldProps extends HTMLAttributes<HTMLDivElement> {
+    /** Text label rendered as a `<label>` element. */
+    label: string;
+    /** Helper text shown between the label and children. */
+    description?: string;
+    /** Error message shown below children in danger color. */
+    error?: string;
+    /** Renders a required asterisk after the label. */
+    required?: boolean;
+    /** Associates the label with a form control via `htmlFor`. */
+    htmlFor: string;
+    /** Controls density/font sizing. @default 'md' */
+    size?: ComponentSize;
+}
+
+export declare const FormSection: ForwardRefExoticComponent<FormSectionProps & RefAttributes<HTMLFieldSetElement>>;
+
+export declare interface FormSectionProps extends FieldsetHTMLAttributes<HTMLFieldSetElement> {
+    /** Section heading rendered as a `<legend>`. */
+    title: string;
+    /** Optional description below the legend. */
+    description?: string;
+}
+
+export declare const Grid: GridCompound;
+
+declare interface GridBaseProps extends HTMLAttributes<HTMLDivElement> {
+    spacing?: GridSpacing;
+    rowSpacing?: GridSpacing;
+    columnSpacing?: GridSpacing;
+}
+
+/** Breakpoints matching common responsive design thresholds. */
+export declare type GridBreakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+declare type GridCompound = typeof GridRoot & {
+    Item: typeof GridItem;
+};
+
+declare const GridItem: ForwardRefExoticComponent<GridItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface GridItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Column span — number for all sizes, or { xs: 12, md: 6 } for responsive. */
+    span?: ResponsiveSpan;
+    rowSpan?: number;
+}
+
+export declare type GridProps = GridPropsWithColumns | GridPropsWithMinChildWidth;
+
+declare interface GridPropsWithColumns extends GridBaseProps {
+    columns?: number;
+    minChildWidth?: never;
+}
+
+declare interface GridPropsWithMinChildWidth extends GridBaseProps {
+    columns?: never;
+    minChildWidth?: string;
+}
+
+declare const GridRoot: ForwardRefExoticComponent<GridProps & RefAttributes<HTMLDivElement>>;
+
+export declare type GridSpacing = Spacing;
+
+declare const Header: ForwardRefExoticComponent<AppShellHeaderProps & RefAttributes<HTMLElement>>;
+
+export declare const Heading: HeadingComponent;
+
+declare type HeadingComponent = <C extends HeadingElement = 'h2'>(props: HeadingProps<C> & {
+    ref?: PolymorphicRef<C>;
+}) => ReactElement | null;
+
+declare type HeadingElement = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'div';
+
+export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+
+declare interface HeadingOwnProps extends TypographyBaseProps, TruncationProps {
+    level?: HeadingLevel;
+}
+
+export declare type HeadingProps<C extends HeadingElement = HeadingElement> = PolymorphicComponentProps<C, HeadingOwnProps>;
+
+/** Range of characters to highlight in a label (from server-side fuzzy matcher). */
+export declare interface HighlightRange {
+    /** Inclusive start index. */
+    start: number;
+    /** Exclusive end index. */
+    end: number;
+}
+
+export declare const Hotkey: <C extends HotkeyElement = "kbd">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+declare type HotkeyElement = 'kbd' | 'span';
+
+export declare type HotkeyProps<E extends HotkeyElement = HotkeyElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare const IconButton: ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & RefAttributes<HTMLElement>>;
+
+export declare interface IconButtonProps extends Omit<ButtonProps, 'children'> {
+    children: ReactNode;
+    dense?: boolean;
+}
+
+declare const Image_2: NamedExoticComponent<ImageProps & RefAttributes<HTMLImageElement>>;
+export { Image_2 as Image }
+
+export declare type ImageBorderRadius = 'none' | 'sm' | 'md' | 'lg' | 'full';
+
+export declare const ImageList: ImageListCompound;
+
+declare type ImageListCompound = typeof ImageListRoot & {
+    Item: typeof ImageListItem;
+};
+
+declare const ImageListItem: ForwardRefExoticComponent<ImageListItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ImageListItemProps extends HTMLAttributes<HTMLDivElement> {
+    colSpan?: number;
+    rowSpan?: number;
+}
+
+export declare interface ImageListProps extends HTMLAttributes<HTMLDivElement> {
+    cols?: number;
+    gap?: Spacing;
+    variant?: ImageListVariant;
+}
+
+declare const ImageListRoot: ForwardRefExoticComponent<ImageListProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ImageListVariant = 'standard' | 'masonry' | 'quilted';
+
+export declare type ImageObjectFit = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+
+export declare interface ImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, 'placeholder'> {
+    fallback?: ReactNode;
+    objectFit?: ImageObjectFit;
+    borderRadius?: ImageBorderRadius;
+}
+
+/** Internal props injected by StepperRoot via Children.map. */
+declare interface InjectedStepProps {
+    /* Excluded from this release type: _index */
+    /* Excluded from this release type: _isFirst */
+}
+
+export declare const Input: InputCompound;
+
+declare type InputCompound = typeof InputRoot & {
+    Root: typeof InputRoot;
+    Label: typeof InputLabel;
+    Control: typeof InputControl;
+    Description: typeof InputDescription;
+    Error: typeof InputError;
+};
+
+declare const InputControl: ForwardRefExoticComponent<InputControlProps & RefAttributes<HTMLElement>>;
+
+export declare interface InputControlProps extends Omit<ComponentPropsWithoutRef<typeof Input_2>, 'size' | 'color'>, StyledComponentProps {
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+    mono?: boolean;
+}
+
+declare const InputDescription: ForwardRefExoticComponent<Omit<FieldDescriptionProps, "ref"> & RefAttributes<HTMLParagraphElement>>;
+
+export declare type InputDescriptionProps = Field.Description.Props;
+
+declare const InputError: ForwardRefExoticComponent<Omit<FieldErrorProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare type InputErrorProps = Field.Error.Props;
+
+declare const InputLabel: ForwardRefExoticComponent<Omit<FieldLabelProps, "ref"> & RefAttributes<HTMLElement>>;
+
+export declare type InputLabelProps = Field.Label.Props;
+
+declare const InputRoot: ForwardRefExoticComponent<Omit<InputRootProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare interface InputRootProps extends Field.Root.Props, StyledComponentProps {
+}
+
+export declare interface ItemState {
+    isSelected: boolean;
+    isActive: boolean;
+    isDisabled: boolean;
+}
+
+export declare type Key = string | number;
+
+declare type Key_2 = string | number;
+
+declare type Key_3 = string | number;
+
+export declare const Link: ForwardRefExoticComponent<LinkProps & RefAttributes<HTMLAnchorElement>>;
+
+export declare interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'color'>, TypographyBaseProps, TruncationProps {
+    underline?: LinkUnderline;
+}
+
+export declare type LinkUnderline = 'always' | 'hover' | 'none';
+
+export declare const List: ListCompound;
+
+declare interface ListActionsContextValue {
+    select: (key: Key) => void;
+    deselect: (key: Key) => void;
+    toggle: (key: Key) => void;
+    selectRange: (toKey: Key) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+    setActiveKey: (key: Key | null) => void;
+    registerItem: (key: Key, textValue?: string) => () => void;
+}
+
+declare type ListCompound = typeof ListRoot & {
+    Root: typeof ListRoot;
+    Viewport: typeof ListViewport;
+    Item: typeof ListItem;
+    ItemIcon: typeof ListItemIcon;
+    ItemLabel: typeof ListItemLabel;
+    ItemDescription: typeof ListItemDescription;
+    ItemMeta: typeof ListItemMeta;
+    ItemActions: typeof ListItemActions;
+    Group: typeof ListGroup;
+    GroupHeader: typeof ListGroupHeader;
+    Separator: typeof ListSeparator;
+    Empty: typeof ListEmpty;
+    Loading: typeof ListLoading;
+};
+
+declare interface ListConfigContextValue {
+    listId: string;
+    selectionMode: SelectionMode_2;
+    selectionBehavior: SelectionBehavior;
+    density: ListDensity;
+    orientation: ListOrientation;
+    typeahead: boolean;
+    loopFocus: boolean;
+    virtualized: boolean;
+}
+
+export declare type ListDensity = 'compact' | 'default' | 'comfortable';
+
+declare type ListDensity_2 = 'compact' | 'default' | 'comfortable';
+
+declare type ListDensity_3 = 'compact' | 'default' | 'comfortable';
+
+declare const ListEmpty: ForwardRefExoticComponent<ListEmptyProps & RefAttributes<HTMLDivElement>>;
+
+declare interface ListEmptyProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+declare const ListGroup: ForwardRefExoticComponent<ListGroupProps & RefAttributes<HTMLDivElement>>;
+
+declare const ListGroupHeader: ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+
+export declare interface ListGroupProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+export declare interface ListHandle {
+    focus: () => void;
+    scrollToKey: (key: Key, align?: ScrollLogicalPosition) => void;
+    getSelectedKeys: () => ReadonlySet<Key>;
+    clearSelection: () => void;
+    selectAll: () => void;
+}
+
+declare const ListItem: ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLDivElement>>;
+
+declare const ListItemActions: ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+
+declare const ListItemDescription: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const ListItemIcon: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const ListItemLabel: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const ListItemMeta: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface ListItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    itemKey: Key;
+    disabled?: boolean;
+    textValue?: string;
+    children: ReactNode;
+}
+
+declare const ListLoading: ForwardRefExoticComponent<ListLoadingProps & RefAttributes<HTMLDivElement>>;
+
+declare interface ListLoadingProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+export declare type ListOrientation = 'vertical' | 'horizontal';
+
+declare const ListRoot: ForwardRefExoticComponent<ListRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ListRootProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+    selectionMode?: SelectionMode_2;
+    selectionBehavior?: SelectionBehavior;
+    selectedKeys?: ReadonlySet<Key>;
+    defaultSelectedKeys?: Iterable<Key>;
+    onSelectedKeysChange?: (keys: ReadonlySet<Key>) => void;
+    activeKey?: Key | null;
+    defaultActiveKey?: Key | null;
+    onActiveKeyChange?: (key: Key | null) => void;
+    disabledKeys?: Iterable<Key>;
+    orientation?: ListOrientation;
+    loopFocus?: boolean;
+    typeahead?: boolean;
+    density?: ListDensity;
+    virtualized?: boolean;
+    overscan?: number;
+    estimatedItemSize?: number;
+    loading?: boolean;
+    error?: ReactNode;
+    children?: ReactNode;
+}
+
+declare const ListSeparator: ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+
+declare interface ListStore {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ListStoreSnapshot;
+    getItemState: (key: Key) => ItemState;
+    setSelectedKeys: (keys: Set<Key>) => void;
+    setActiveKey: (key: Key | null) => void;
+    registerItem: (key: Key, textValue?: string) => () => void;
+    getRegisteredKeys: () => Key[];
+    getTextValue: (key: Key) => string | undefined;
+}
+
+declare interface ListStoreSnapshot {
+    selectedKeys: ReadonlySet<Key>;
+    activeKey: Key | null;
+    disabledKeys: ReadonlySet<Key>;
+    registeredKeys: Key[];
+}
+
+declare const ListViewport: ForwardRefExoticComponent<ListViewportProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ListViewportProps extends HTMLAttributes<HTMLDivElement> {
+    onReachEnd?: () => void;
+}
+
+export declare const Menu: MenuCompound;
+
+declare const MenuBackdrop: ForwardRefExoticComponent<Omit<Omit<ContextMenuBackdropProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const MenuCheckboxItem: ForwardRefExoticComponent<MenuCheckboxItemProps & RefAttributes<HTMLElement>>;
+
+declare const MenuCheckboxItemIndicator: ForwardRefExoticComponent<Omit<Omit<ContextMenuCheckboxItemIndicatorProps, "ref"> & RefAttributes<HTMLSpanElement>, "ref"> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface MenuCheckboxItemProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.CheckboxItem>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_3 {
+}
+
+declare type MenuCompound = typeof MenuRoot & {
+    Root: typeof MenuRoot;
+    Trigger: typeof MenuTrigger;
+    Portal: typeof Menu_2.Portal;
+    Backdrop: typeof MenuBackdrop;
+    Positioner: typeof MenuPositioner;
+    Popup: typeof MenuPopup;
+    Arrow: typeof Menu_2.Arrow;
+    Group: typeof Menu_2.Group;
+    GroupLabel: typeof MenuGroupLabel;
+    Item: typeof MenuItem;
+    LinkItem: typeof MenuLinkItem;
+    CheckboxItem: typeof MenuCheckboxItem;
+    CheckboxItemIndicator: typeof MenuCheckboxItemIndicator;
+    RadioGroup: typeof Menu_2.RadioGroup;
+    RadioItem: typeof MenuRadioItem;
+    RadioItemIndicator: typeof MenuRadioItemIndicator;
+    SubmenuRoot: typeof Menu_2.SubmenuRoot;
+    SubmenuTrigger: typeof MenuSubmenuTrigger;
+    Separator: typeof MenuSeparator;
+    Handle: typeof Menu_2.Handle;
+    createHandle: typeof Menu_2.createHandle;
+};
+
+declare const MenuGroupLabel: ForwardRefExoticComponent<Omit<Omit<Omit<ContextMenuGroupLabelProps, "ref"> & RefAttributes<HTMLDivElement>, "ref">, "color"> & StyledComponentProps & RefAttributes<HTMLDivElement>>;
+
+declare const MenuItem: ForwardRefExoticComponent<MenuItemProps & RefAttributes<HTMLElement>>;
+
+export declare interface MenuItemProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.Item>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_3 {
+}
+
+declare const MenuLinkItem: ForwardRefExoticComponent<MenuLinkItemProps & RefAttributes<Element>>;
+
+export declare interface MenuLinkItemProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.LinkItem>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_3 {
+}
+
+declare const MenuPopup: ForwardRefExoticComponent<MenuPopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface MenuPopupProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const MenuPositioner: ForwardRefExoticComponent<Omit<Omit<ContextMenuPositionerProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const MenuRadioItem: ForwardRefExoticComponent<MenuRadioItemProps & RefAttributes<HTMLElement>>;
+
+declare const MenuRadioItemIndicator: ForwardRefExoticComponent<Omit<Omit<ContextMenuRadioItemIndicatorProps, "ref"> & RefAttributes<HTMLSpanElement>, "ref"> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface MenuRadioItemProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.RadioItem>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_3 {
+}
+
+declare const MenuRoot: {
+    ({ variant, color, size, ...props }: MenuRootProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface MenuRootProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.Root>, 'color'>, StyledComponentProps {
+}
+
+declare const MenuSeparator: ForwardRefExoticComponent<Omit<Omit<Omit<SeparatorProps_2, "ref"> & RefAttributes<HTMLDivElement>, "ref">, "color"> & StyledComponentProps & RefAttributes<HTMLDivElement>>;
+
+declare const MenuSubmenuTrigger: ForwardRefExoticComponent<MenuSubmenuTriggerProps & RefAttributes<HTMLElement>>;
+
+export declare interface MenuSubmenuTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.SubmenuTrigger>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_3 {
+    showCaret?: boolean;
+}
+
+declare const MenuTrigger: {
+    ({ className, variant, color, size, render, ...props }: MenuTriggerProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface MenuTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Menu_2.Trigger>, 'color'>, StyledComponentProps {
+    /** Custom render element — when provided, the default Trigger styling is skipped. */
+    render?: Menu_2.Trigger.Props['render'];
+}
+
+export declare const Meter: ForwardRefExoticComponent<MeterProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface MeterProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    value: number;
+    min?: number;
+    max?: number;
+    low?: number;
+    high?: number;
+    optimum?: number;
+    size?: ComponentSize;
+    color?: ComponentColor;
+    label?: ReactNode;
+}
+
+export declare function MultiSelect<Item = string>({ items, value, defaultValue, onValueChange, variant, color, size, label, placeholder, searchPlaceholder, emptyMessage, className, controlClassName, popupClassName, listClassName, maxVisibleChips, showItemIndicator, getItemLabel, getItemValue, getItemKey, getItemDisabled, renderChipLabel, renderItemLabel, renderItemEndDecorator, removeButtonLabel, triggerLabel, clearable, clearButtonLabel, clearDecorator, ...props }: MultiSelectProps<Item>): JSX.Element;
+
+export declare namespace MultiSelect {
+    var displayName: string;
+}
+
+export declare interface MultiSelectProps<Item = string> extends Omit<Combobox_2.Root.Props<Item, true>, 'multiple' | 'children' | 'color' | 'itemToStringLabel' | 'itemToStringValue'>, StyledComponentProps {
+    label?: ReactNode;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: ReactNode;
+    className?: string;
+    controlClassName?: string;
+    popupClassName?: string;
+    listClassName?: string;
+    maxVisibleChips?: number;
+    showItemIndicator?: boolean;
+    getItemLabel?: (item: Item) => string;
+    getItemValue?: (item: Item) => string;
+    getItemKey?: (item: Item, index: number) => string;
+    getItemDisabled?: (item: Item) => boolean;
+    renderChipLabel?: (item: Item) => ReactNode;
+    renderItemLabel?: (item: Item) => ReactNode;
+    renderItemEndDecorator?: (item: Item) => ReactNode;
+    removeButtonLabel?: (item: Item) => string;
+    triggerLabel?: string;
+    clearable?: boolean;
+    clearButtonLabel?: string;
+    clearDecorator?: ReactNode;
+}
+
+export declare const NavList: NavListCompound;
+
+declare type NavListCompound = typeof NavListRoot & {
+    Root: typeof NavListRoot;
+    Viewport: typeof List.Viewport;
+    Item: typeof NavListItem;
+    ItemIcon: typeof List.ItemIcon;
+    ItemLabel: typeof List.ItemLabel;
+    ItemDescription: typeof List.ItemDescription;
+    ItemMeta: typeof List.ItemMeta;
+    ItemActions: typeof List.ItemActions;
+    Group: typeof NavListGroup;
+    GroupHeader: typeof NavListGroupHeader;
+    GroupItems: typeof NavListGroupItems;
+    Separator: typeof List.Separator;
+    Empty: typeof List.Empty;
+    Loading: typeof List.Loading;
+};
+
+declare const NavListGroup: ForwardRefExoticComponent<NavListGroupProps & RefAttributes<HTMLDivElement>>;
+
+declare const NavListGroupHeader: ForwardRefExoticComponent<NavListGroupHeaderProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NavListGroupHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+declare const NavListGroupItems: ForwardRefExoticComponent<NavListGroupItemsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NavListGroupItemsProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+export declare interface NavListGroupProps extends ListGroupProps {
+    collapsible?: boolean;
+    defaultExpanded?: boolean;
+    expanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+}
+
+declare const NavListItem: ForwardRefExoticComponent<NavListItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NavListItemProps extends ListItemProps {
+    unread?: boolean;
+    dirty?: boolean;
+}
+
+declare const NavListRoot: ForwardRefExoticComponent<NavListRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NavListRootProps extends Omit<ListRootProps, 'density'> {
+    density?: ListRootProps['density'];
+}
+
+declare const NavRail: ForwardRefExoticComponent<AppShellNavRailProps & RefAttributes<HTMLElement>>;
+
+export declare const NumberInput: NumberInputCompound;
+
+declare type NumberInputCompound = typeof NumberInputRoot & {
+    Root: typeof NumberInputRoot;
+    Label: typeof NumberInputLabel;
+    Group: typeof NumberInputGroup;
+    Input: typeof NumberInputInput;
+    Increment: typeof NumberInputIncrement;
+    Decrement: typeof NumberInputDecrement;
+    Description: typeof NumberInputDescription;
+    Error: typeof NumberInputError;
+    ScrubArea: typeof NumberField.ScrubArea;
+    ScrubAreaCursor: typeof NumberField.ScrubAreaCursor;
+};
+
+declare const NumberInputDecrement: ForwardRefExoticComponent<NumberInputStepperProps & RefAttributes<HTMLButtonElement>>;
+
+declare const NumberInputDescription: ForwardRefExoticComponent<NumberInputDescriptionProps & RefAttributes<HTMLParagraphElement>>;
+
+export declare type NumberInputDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+
+declare const NumberInputError: ForwardRefExoticComponent<NumberInputErrorProps & RefAttributes<HTMLDivElement>>;
+
+export declare type NumberInputErrorProps = HTMLAttributes<HTMLDivElement>;
+
+declare const NumberInputGroup: ForwardRefExoticComponent<NumberInputGroupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NumberInputGroupProps extends Omit<ComponentPropsWithoutRef<typeof NumberField.Group>, 'color'>, StyledComponentProps {
+}
+
+declare const NumberInputIncrement: ForwardRefExoticComponent<NumberInputStepperProps & RefAttributes<HTMLButtonElement>>;
+
+declare const NumberInputInput: ForwardRefExoticComponent<NumberInputInputProps & RefAttributes<HTMLInputElement>>;
+
+export declare interface NumberInputInputProps extends Omit<ComponentPropsWithoutRef<typeof NumberField.Input>, 'color' | 'size'>, StyledComponentProps {
+}
+
+declare const NumberInputLabel: ForwardRefExoticComponent<NumberInputLabelProps & RefAttributes<HTMLLabelElement>>;
+
+export declare type NumberInputLabelProps = LabelHTMLAttributes<HTMLLabelElement>;
+
+declare const NumberInputRoot: ForwardRefExoticComponent<NumberInputRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NumberInputRootProps extends Omit<ComponentPropsWithoutRef<typeof NumberField.Root>, 'color'>, StyledComponentProps {
+}
+
+export declare interface NumberInputStepperProps extends Omit<ComponentPropsWithoutRef<typeof NumberField.Increment>, 'color'>, StyledComponentProps {
+    children?: ReactNode;
+}
+
+export declare const Overline: <C extends OverlineElement = "span">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+declare type OverlineElement = 'span' | 'p' | 'div';
+
+export declare type OverlineProps<E extends OverlineElement = OverlineElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare const Pagination: ForwardRefExoticComponent<PaginationProps & RefAttributes<HTMLElement>>;
+
+export declare interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'> {
+    /** Total number of pages. */
+    count: number;
+    /** Current active page (1-indexed). */
+    page: number;
+    /** Called when the user selects a page. */
+    onChange: (page: number) => void;
+    /** Number of sibling pages to show on each side of the current page. @default 1 */
+    siblingCount?: number;
+    /** Number of boundary pages to always show at start/end. @default 1 */
+    boundaryCount?: number;
+    /** Whether to show first/last navigation buttons. @default true */
+    showFirstLast?: boolean;
+    /** Component size. @default 'md' */
+    size?: ComponentSize;
+}
+
+export declare const Paper: ForwardRefExoticComponent<SheetProps & RefAttributes<HTMLElement>>;
+
+declare type PolymorphicComponentProps<C extends ElementType, Props = Record<string, never>> = Props & {
+    as?: C;
+} & Omit<ComponentPropsWithoutRef<C>, keyof Props | 'as' | 'color'>;
+
+declare type PolymorphicRef<C extends ElementType> = ComponentPropsWithRef<C>['ref'];
+
+export declare const Popover: PopoverCompound;
+
+declare const PopoverArrow: ForwardRefExoticComponent<PopoverArrowProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface PopoverArrowProps extends Omit<ComponentPropsWithoutRef<typeof Popover_2.Arrow>, 'color'>, StyledComponentProps {
+}
+
+declare const PopoverBackdrop: ForwardRefExoticComponent<Omit<Omit<PopoverBackdropProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const PopoverClose: ForwardRefExoticComponent<PopoverCloseProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface PopoverCloseProps extends Omit<ComponentPropsWithoutRef<typeof Popover_2.Close>, 'color'>, StyledComponentProps {
+}
+
+declare type PopoverCompound = typeof PopoverRoot & {
+    Root: typeof PopoverRoot;
+    Trigger: typeof PopoverTrigger;
+    Portal: typeof PopoverPortal;
+    Backdrop: typeof PopoverBackdrop;
+    Positioner: typeof PopoverPositioner;
+    Popup: typeof PopoverPopup;
+    Arrow: typeof PopoverArrow;
+    Title: typeof PopoverTitle;
+    Description: typeof PopoverDescription;
+    Close: typeof PopoverClose;
+    Viewport: typeof PopoverViewport;
+    Handle: typeof Popover_2.Handle;
+    createHandle: typeof Popover_2.createHandle;
+};
+
+declare const PopoverDescription: ForwardRefExoticComponent<Omit<Omit<PopoverDescriptionProps, "ref"> & RefAttributes<HTMLParagraphElement>, "ref"> & RefAttributes<HTMLParagraphElement>>;
+
+declare const PopoverPopup: ForwardRefExoticComponent<PopoverPopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface PopoverPopupProps extends Omit<ComponentPropsWithoutRef<typeof Popover_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const PopoverPortal: ForwardRefExoticComponent<Omit<Omit<PopoverPortalProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const PopoverPositioner: ForwardRefExoticComponent<Omit<Omit<PopoverPositionerProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare function PopoverRoot<Payload>({ variant, color, size, ...props }: PopoverRootProps<Payload>): JSX.Element;
+
+declare namespace PopoverRoot {
+    var displayName: string;
+}
+
+export declare type PopoverRootProps<Payload = unknown> = Omit<Popover_2.Root.Props<Payload>, 'color'> & StyledComponentProps;
+
+declare const PopoverTitle: ForwardRefExoticComponent<Omit<Omit<PopoverTitleProps, "ref"> & RefAttributes<HTMLHeadingElement>, "ref"> & RefAttributes<HTMLHeadingElement>>;
+
+declare const PopoverTrigger: ForwardRefExoticComponent<PopoverTriggerProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface PopoverTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Popover_2.Trigger>, 'color'>, StyledComponentProps {
+}
+
+declare const PopoverViewport: ForwardRefExoticComponent<Omit<Omit<Popover_2.Viewport.Props, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare interface ProcessedItem<TItem = unknown> {
+    key: Key_2;
+    item: TItem;
+    groupKey?: string;
+    score?: number;
+    highlights?: HighlightRange[];
+    disabled: boolean;
+}
+
+export declare const Progress: ForwardRefExoticComponent<ProgressProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ProgressProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    value?: number;
+    variant?: ComponentVariant;
+    color?: ComponentColor;
+    size?: ComponentSize;
+}
+
+export declare const Quote: <C extends QuoteElement = "q">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+declare type QuoteElement = 'q' | 'span';
+
+export declare type QuoteProps<E extends QuoteElement = QuoteElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare const Radio: RadioCompound;
+
+declare type RadioCompound = typeof RadioItem & {
+    Root: typeof RadioRoot;
+    Control: typeof RadioControl;
+    Indicator: typeof RadioIndicator;
+    Label: typeof RadioLabel;
+    Description: typeof RadioDescription;
+    Item: typeof RadioItem;
+};
+
+declare const RadioControl: ForwardRefExoticComponent<RadioControlProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type RadioControlProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const RadioDescription: ForwardRefExoticComponent<RadioDescriptionProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type RadioDescriptionProps = HTMLAttributes<HTMLSpanElement>;
+
+export declare const RadioGroup: RadioGroupCompound;
+
+declare type RadioGroupCompound = typeof RadioGroupRoot & {
+    Item: typeof RadioGroupItem;
+};
+
+declare function RadioGroupItem({ className, variant, color, size, ...props }: RadioGroupItemProps): JSX.Element;
+
+declare namespace RadioGroupItem {
+    var displayName: string;
+}
+
+export declare interface RadioGroupItemProps extends Omit<RadioItemProps, 'variant' | 'color' | 'size' | 'value'>, StyledComponentProps {
+    value: string;
+}
+
+export declare interface RadioGroupProps extends Omit<ComponentPropsWithoutRef<typeof RadioGroup_2<string>>, 'color'>, StyledComponentProps {
+    orientation?: 'vertical' | 'horizontal';
+}
+
+declare function RadioGroupRoot({ className, variant, color, size, orientation, ...props }: RadioGroupProps): JSX.Element;
+
+declare namespace RadioGroupRoot {
+    var displayName: string;
+}
+
+declare const RadioIndicator: ForwardRefExoticComponent<RadioIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface RadioIndicatorProps extends Omit<ComponentPropsWithoutRef<typeof Radio_2.Indicator>, 'color'>, StyledComponentProps {
+}
+
+declare const RadioItem: ForwardRefExoticComponent<RadioItemProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface RadioItemProps extends Omit<RadioRootProps, 'children'> {
+    children?: ReactNode;
+    description?: ReactNode;
+    indicator?: ReactNode;
+    keepIndicatorMounted?: boolean;
+}
+
+declare const RadioLabel: ForwardRefExoticComponent<RadioLabelProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type RadioLabelProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const RadioRoot: ForwardRefExoticComponent<RadioRootProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface RadioRootProps extends Omit<ComponentPropsWithoutRef<typeof Radio_2.Root<string>>, 'color' | 'value'>, StyledComponentProps {
+    value: string;
+}
+
+export declare type ReorderMeta = {
+    id: TabId;
+    from: number;
+    to: number;
+};
+
+export declare const ResizableSplitPane: ForwardRefExoticComponent<ResizableSplitPaneProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ResizableSplitPaneProps extends HTMLAttributes<HTMLDivElement> {
+    /** Split direction. 'horizontal' = side by side, 'vertical' = stacked. */
+    direction?: SplitDirection;
+    /** Initial size of the sized pane in pixels. */
+    defaultSize?: number;
+    /** Minimum size of the sized pane in pixels. */
+    minSize?: number;
+    /** Maximum size of the sized pane in pixels. */
+    maxSize?: number;
+    /** When true, the second pane is the sized pane instead of the first. */
+    reverse?: boolean;
+    /** Accessible label for the resize handle (role="separator"). */
+    handleLabel?: string;
+    /** Callback fired during resize with the current sized-pane size in px. */
+    onResize?: (size: number) => void;
+    /** The two pane contents. */
+    children: [ReactNode, ReactNode];
+}
+
+/** A span value can be a plain number or a per-breakpoint responsive object. */
+export declare type ResponsiveSpan = number | Partial<Record<GridBreakpoint, number>>;
+
+/**
+ * Pre-computed row heights for each DataTable size variant.
+ * Use with `fixedRowHeight` + `estimateRowSize` for optimal virtual scrolling.
+ * These match the CSS `--ov-size-table-row-height-{size}` tokens.
+ */
+export declare const ROW_HEIGHT: {
+    readonly sm: 30;
+    readonly md: 36;
+    readonly lg: 44;
+};
+
+export declare const RowList: RowListCompound;
+
+declare const RowListCell: ForwardRefExoticComponent<RowListCellProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface RowListCellProps extends HTMLAttributes<HTMLDivElement> {
+    /** Which column this cell belongs to (matches ColumnDef.id) */
+    column: string;
+    children?: ReactNode;
+}
+
+declare type RowListCompound = typeof RowListRoot & {
+    Root: typeof RowListRoot;
+    Header: typeof RowListHeader;
+    Viewport: typeof List.Viewport;
+    Item: typeof RowListItem;
+    Cell: typeof RowListCell;
+    Group: typeof List.Group;
+    GroupHeader: typeof List.GroupHeader;
+    Separator: typeof List.Separator;
+    Empty: typeof List.Empty;
+    Loading: typeof List.Loading;
+};
+
+declare const RowListHeader: ForwardRefExoticComponent<RowListHeaderProps & RefAttributes<HTMLDivElement>>;
+
+export declare type RowListHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+declare const RowListItem: ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare type RowListItemProps = ListItemProps;
+
+declare const RowListRoot: ForwardRefExoticComponent<RowListRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface RowListRootProps extends ListRootProps {
+    /** Column definitions drive the grid layout and header rendering */
+    columns: readonly ColumnDef[];
+    /** Current sort state (visual only — consumer sorts data) */
+    sortState?: SortState | null;
+    /** Called when a sortable column header is clicked */
+    onSortChange?: (sort: SortState) => void;
+}
+
+export declare const ScrollArea: ForwardRefExoticComponent<ScrollAreaProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ScrollAreaOrientation = 'vertical' | 'horizontal' | 'both';
+
+export declare interface ScrollAreaProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: ScrollAreaOrientation;
+    size?: ComponentSize;
+}
+
+declare interface ScrollState {
+    canScrollLeft: boolean;
+    canScrollRight: boolean;
+}
+
+export declare const SearchInput: ForwardRefExoticComponent<SearchInputProps & RefAttributes<HTMLElement>>;
+
+export declare interface SearchInputProps extends Omit<InputControlProps, 'startDecorator' | 'endDecorator' | 'onValueChange' | 'value' | 'defaultValue' | 'type' | 'className' | 'variant' | 'color' | 'size' | 'style'>, StyledComponentProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onClear?: () => void;
+    clearable?: boolean;
+    clearButtonLabel?: string;
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+    clearDecorator?: ReactNode;
+    style?: CSSProperties;
+    className?: string;
+    controlClassName?: string;
+    rootProps?: Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'color'>;
+}
+
+declare const SecondarySidebar: ForwardRefExoticComponent<AppShellSecondarySidebarProps & RefAttributes<HTMLElement>>;
+
+export declare const SegmentedControl: SegmentedControlCompound;
+
+declare type SegmentedControlCompound = typeof SegmentedControlRoot & {
+    Item: typeof SegmentedControlItem;
+};
+
+declare const SegmentedControlItem: ForwardRefExoticComponent<SegmentedControlItemProps & RefAttributes<HTMLLabelElement>>;
+
+export declare interface SegmentedControlItemProps extends Omit<HTMLAttributes<HTMLLabelElement>, 'onChange'> {
+    value: string;
+    disabled?: boolean;
+    children: ReactNode;
+}
+
+export declare interface SegmentedControlProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    size?: ComponentSize;
+    disabled?: boolean;
+    children: ReactNode;
+}
+
+declare const SegmentedControlRoot: ForwardRefExoticComponent<SegmentedControlProps & RefAttributes<HTMLDivElement>>;
+
+export declare const Select: SelectCompound;
+
+export declare const SelectableList: SelectableListCompound;
+
+declare type SelectableListCompound = typeof SelectableListRoot & {
+    Root: typeof SelectableListRoot;
+    Viewport: typeof List.Viewport;
+    Item: typeof SelectableListItem;
+    ItemIndicator: typeof SelectableListItemIndicator;
+    ItemIcon: typeof List.ItemIcon;
+    ItemLabel: typeof List.ItemLabel;
+    ItemDescription: typeof List.ItemDescription;
+    ItemMeta: typeof List.ItemMeta;
+    ItemActions: typeof List.ItemActions;
+    SelectAll: typeof SelectableListSelectAll;
+    SelectionSummary: typeof SelectableListSelectionSummary;
+    Group: typeof List.Group;
+    GroupHeader: typeof List.GroupHeader;
+    GroupSelectAll: typeof SelectableListGroupSelectAll;
+    Separator: typeof List.Separator;
+    Empty: typeof List.Empty;
+    Loading: typeof List.Loading;
+};
+
+declare const SelectableListGroupSelectAll: ForwardRefExoticComponent<SelectableListGroupSelectAllProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SelectableListGroupSelectAllProps extends HTMLAttributes<HTMLDivElement> {
+    /** Keys of items in this group, used to compute indeterminate state */
+    groupKeys: readonly Key[];
+    children?: ReactNode;
+}
+
+declare const SelectableListItem: ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLDivElement>>;
+
+declare const SelectableListItemIndicator: ForwardRefExoticComponent<SelectableListItemIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type SelectableListItemIndicatorProps = HTMLAttributes<HTMLSpanElement>;
+
+export declare type SelectableListItemProps = ListItemProps;
+
+declare const SelectableListRoot: ForwardRefExoticComponent<SelectableListRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SelectableListRootProps extends ListRootProps {
+    /**
+     * Visual indicator type.
+     * Defaults to 'checkbox' when selectionMode='multiple',
+     * 'radio' when selectionMode='single'.
+     */
+    checkBehavior?: CheckBehavior;
+}
+
+declare const SelectableListSelectAll: ForwardRefExoticComponent<SelectableListSelectAllProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SelectableListSelectAllProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+declare const SelectableListSelectionSummary: ForwardRefExoticComponent<SelectableListSelectionSummaryProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SelectableListSelectionSummaryProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Custom render function. If omitted, renders "N of M selected" */
+    children?: ReactNode | ((selected: number, total: number) => ReactNode);
+}
+
+declare const SelectArrow: ForwardRefExoticComponent<Omit<Omit<SelectArrowProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const SelectBackdrop: ForwardRefExoticComponent<Omit<Omit<SelectBackdropProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare type SelectCompound = typeof SelectRoot & {
+    Root: typeof SelectRoot;
+    Trigger: typeof SelectTrigger;
+    Value: typeof SelectValue;
+    Icon: typeof SelectIcon;
+    Portal: typeof Select_2.Portal;
+    Backdrop: typeof SelectBackdrop;
+    Positioner: typeof SelectPositioner;
+    Popup: typeof SelectPopup;
+    Arrow: typeof SelectArrow;
+    ScrollUpArrow: typeof SelectScrollUpArrow;
+    ScrollDownArrow: typeof SelectScrollDownArrow;
+    List: typeof SelectList;
+    Group: typeof Select_2.Group;
+    GroupLabel: typeof SelectGroupLabel;
+    Item: typeof SelectItem;
+    ItemIndicator: typeof SelectItemIndicator;
+    ItemText: typeof SelectItemText;
+    Separator: typeof SelectSeparator;
+};
+
+declare const SelectGroupLabel: ForwardRefExoticComponent<Omit<Omit<Omit<SelectGroupLabelProps, "ref"> & RefAttributes<HTMLDivElement>, "ref">, "color"> & StyledComponentProps & RefAttributes<HTMLDivElement>>;
+
+declare const SelectIcon: ForwardRefExoticComponent<SelectIconProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface SelectIconProps extends Omit<ComponentPropsWithoutRef<typeof Select_2.Icon>, 'color'>, StyledComponentProps {
+}
+
+export declare type SelectionBehavior = 'replace' | 'toggle';
+
+declare type SelectionBehavior_2 = 'replace' | 'toggle';
+
+declare type SelectionIndicatorMode = 'auto' | 'always' | 'never';
+
+declare type SelectionMode_2 = 'none' | 'single' | 'multiple';
+export { SelectionMode_2 as SelectionMode }
+
+declare type SelectionMode_3 = 'none' | 'single' | 'multiple';
+
+declare const SelectItem: ForwardRefExoticComponent<SelectItemProps & RefAttributes<HTMLElement>>;
+
+declare const SelectItemIndicator: ForwardRefExoticComponent<Omit<Omit<SelectItemIndicatorProps, "ref"> & RefAttributes<HTMLSpanElement>, "ref"> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface SelectItemProps extends Omit<ComponentPropsWithoutRef<typeof Select_2.Item>, 'color' | 'children'>, StyledComponentProps, DecoratedContentProps_4 {
+    selectionIndicator?: boolean;
+}
+
+declare const SelectItemText: ForwardRefExoticComponent<Omit<Omit<SelectItemTextProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const SelectList: ForwardRefExoticComponent<SelectListProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SelectListProps extends Omit<ComponentPropsWithoutRef<typeof Select_2.List>, 'color'>, StyledComponentProps {
+}
+
+declare const SelectPopup: ForwardRefExoticComponent<SelectPopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SelectPopupProps extends Omit<ComponentPropsWithoutRef<typeof Select_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const SelectPositioner: ForwardRefExoticComponent<Omit<Omit<SelectPositionerProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare function SelectRoot<Value, Multiple extends boolean | undefined = false>({ variant, color, size, selectionIndicator, multiple, ...props }: SelectRootProps<Value, Multiple>): JSX.Element;
+
+declare namespace SelectRoot {
+    var displayName: string;
+}
+
+export declare type SelectRootProps<Value, Multiple extends boolean | undefined = false> = Omit<Select_2.Root.Props<Value, Multiple>, 'color'> & StyledComponentProps & {
+    selectionIndicator?: SelectionIndicatorMode;
+};
+
+declare const SelectScrollDownArrow: ForwardRefExoticComponent<Omit<Omit<SelectScrollDownArrowProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const SelectScrollUpArrow: ForwardRefExoticComponent<Omit<Omit<SelectScrollUpArrowProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const SelectSeparator: ForwardRefExoticComponent<Omit<Omit<Omit<SeparatorProps_2, "ref"> & RefAttributes<HTMLDivElement>, "ref">, "color"> & StyledComponentProps & RefAttributes<HTMLDivElement>>;
+
+declare const SelectTrigger: ForwardRefExoticComponent<SelectTriggerProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface SelectTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Select_2.Trigger>, 'color'>, StyledComponentProps, DecoratedContentProps_4 {
+}
+
+declare const SelectValue: ForwardRefExoticComponent<SelectValueProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface SelectValueProps extends Omit<ComponentPropsWithoutRef<typeof Select_2.Value>, 'color'>, StyledComponentProps {
+}
+
+export declare const Separator: SeparatorCompound;
+
+declare type SeparatorCompound = typeof SeparatorRoot & {
+    Root: typeof SeparatorRoot;
+};
+
+export declare type SeparatorInset = 'none' | 'start' | 'end' | 'middle';
+
+export declare type SeparatorLabelAlign = 'start' | 'center' | 'end';
+
+export declare type SeparatorOrientation = 'horizontal' | 'vertical';
+
+export declare interface SeparatorProps extends Omit<ComponentPropsWithoutRef<typeof Separator_2>, 'color'>, StyledComponentProps {
+    orientation?: SeparatorOrientation;
+    inset?: SeparatorInset;
+    label?: ReactNode;
+    labelAlign?: SeparatorLabelAlign;
+    decorative?: boolean;
+}
+
+declare const SeparatorRoot: ForwardRefExoticComponent<SeparatorProps & RefAttributes<HTMLDivElement>>;
+
+export declare const Sheet: ForwardRefExoticComponent<SheetProps & RefAttributes<HTMLElement>>;
+
+/** @deprecated Use `SurfaceElevation` from `system/types` instead. */
+export declare type SheetElevation = SurfaceElevation;
+
+export declare interface SheetProps extends Omit<HTMLAttributes<HTMLElement>, 'color'>, StyledComponentProps {
+    as?: 'div' | 'section' | 'article' | 'aside' | 'main' | 'nav' | 'header' | 'footer';
+    elevation?: SurfaceElevation;
+    surface?: SurfaceType;
+}
+
+/** @deprecated Use `SurfaceType` from `system/types` instead. */
+export declare type SheetSurface = SurfaceType;
+
+declare const Sidebar: ForwardRefExoticComponent<AppShellSidebarProps & RefAttributes<HTMLElement>>;
+
+export declare const Skeleton: ForwardRefExoticComponent<SkeletonProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: SkeletonVariant;
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+    animation?: 'pulse' | 'wave' | 'none';
+    size?: SkeletonSize;
+}
+
+declare type SkeletonSize = 'sm' | 'md' | 'lg';
+
+export declare type SkeletonVariant = 'text' | 'circular' | 'rectangular' | 'rounded';
+
+export declare const Slider: SliderCompound;
+
+declare type SliderCompound = typeof SliderRoot & {
+    Root: typeof SliderRoot;
+    Label: typeof SliderLabel;
+    Value: typeof SliderValue;
+    Control: typeof SliderControl;
+    Track: typeof SliderTrack;
+    Indicator: typeof SliderIndicator;
+    Thumb: typeof SliderThumb;
+};
+
+declare const SliderControl: ForwardRefExoticComponent<SliderControlProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SliderControlProps extends Omit<ComponentPropsWithoutRef<typeof Slider_2.Control>, 'color'>, StyledComponentProps {
+}
+
+declare const SliderIndicator: ForwardRefExoticComponent<SliderIndicatorProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SliderIndicatorProps extends Omit<ComponentPropsWithoutRef<typeof Slider_2.Indicator>, 'color'>, StyledComponentProps {
+}
+
+declare const SliderLabel: ForwardRefExoticComponent<SliderLabelProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type SliderLabelProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const SliderRoot: ForwardRefExoticComponent<SliderRootProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SliderRootProps extends Omit<ComponentPropsWithoutRef<typeof Slider_2.Root>, 'color'>, StyledComponentProps {
+}
+
+declare const SliderThumb: ForwardRefExoticComponent<SliderThumbProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SliderThumbProps extends Omit<ComponentPropsWithoutRef<typeof Slider_2.Thumb>, 'color'>, StyledComponentProps {
+}
+
+declare const SliderTrack: ForwardRefExoticComponent<SliderTrackProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SliderTrackProps extends Omit<ComponentPropsWithoutRef<typeof Slider_2.Track>, 'color'>, StyledComponentProps {
+}
+
+declare const SliderValue: ForwardRefExoticComponent<SliderValueProps & RefAttributes<HTMLOutputElement>>;
+
+export declare interface SliderValueProps extends Omit<ComponentPropsWithoutRef<typeof Slider_2.Value>, 'color'>, StyledComponentProps {
+}
+
+export declare interface SortableColumnDef<T> {
+    id: string;
+    header: ReactNode;
+    accessor: (item: T) => string | number | Date | undefined;
+    sortable?: boolean;
+    sortFn?: (a: T, b: T) => number;
+}
+
+export declare function SortableHeader({ columnId, sort, onSort, sortable, children, }: SortableHeaderProps): JSX.Element;
+
+export declare interface SortableHeaderProps {
+    columnId: string;
+    sort: SortConfig;
+    onSort: (columnId: string) => void;
+    sortable?: boolean;
+    children: ReactNode;
+}
+
+export declare interface SortConfig {
+    key: string;
+    direction: 'asc' | 'desc';
+}
+
+export declare type SortDirection = 'ascending' | 'descending';
+
+export declare interface SortState {
+    columnId: string;
+    direction: SortDirection;
+}
+
+declare type Spacing = 0 | 1 | 2 | 3 | 4;
+
+export declare const Spinner: ForwardRefExoticComponent<SpinnerProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface SpinnerProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color' | 'children'> {
+    size?: ComponentSize;
+    color?: ComponentColor;
+}
+
+export declare const SplitButton: SplitButtonCompound;
+
+declare const SplitButtonAction: ForwardRefExoticComponent<SplitButtonActionProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface SplitButtonActionProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'color'> {
+    disabled?: boolean;
+}
+
+declare type SplitButtonColor = 'neutral' | 'brand' | 'success' | 'warning' | 'danger';
+
+declare type SplitButtonCompound = typeof SplitButtonRoot & {
+    Action: typeof SplitButtonAction;
+    Menu: typeof SplitButtonMenu;
+};
+
+declare const SplitButtonMenu: ForwardRefExoticComponent<SplitButtonMenuProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface SplitButtonMenuProps {
+    children: ReactNode;
+    /** Accessible label for the menu trigger button. @default 'More actions' */
+    menuAriaLabel?: string;
+}
+
+export declare interface SplitButtonProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    variant?: ComponentVariant;
+    color?: SplitButtonColor;
+    size?: ComponentSize;
+    disabled?: boolean;
+}
+
+declare const SplitButtonRoot: ForwardRefExoticComponent<SplitButtonProps & RefAttributes<HTMLDivElement>>;
+
+export declare type SplitDirection = 'horizontal' | 'vertical';
+
+export declare const Stack: ForwardRefExoticComponent<StackProps & RefAttributes<HTMLElement>>;
+
+export declare type StackDirection = 'row' | 'column' | 'row-reverse' | 'column-reverse';
+
+export declare interface StackProps extends HTMLAttributes<HTMLElement> {
+    as?: 'div' | 'section' | 'nav' | 'ul' | 'ol';
+    direction?: StackDirection;
+    spacing?: StackSpacing;
+    align?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+    wrap?: boolean;
+    divider?: boolean;
+}
+
+export declare type StackSpacing = 0 | 1 | 2 | 3 | 4;
+
+export declare const StatRow: StatRowCompound;
+
+declare type StatRowCompound = typeof StatRowRoot & {
+    Item: typeof StatRowItem;
+};
+
+declare const StatRowItem: ForwardRefExoticComponent<StatRowItemProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface StatRowItemProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
+    /** Optional icon rendered before the label. */
+    icon?: ReactNode;
+    /** Semantic color for this item. */
+    color?: ComponentColor;
+}
+
+export declare interface StatRowProps extends HTMLAttributes<HTMLDivElement> {
+    /** Size of the row. Default: 'sm'. */
+    size?: ComponentSize;
+    /**
+     * Separator character rendered between items.
+     * Default: '·' (middle dot). Set to `null` to disable automatic separators.
+     */
+    separator?: string | null;
+}
+
+declare const StatRowRoot: ForwardRefExoticComponent<StatRowProps & RefAttributes<HTMLDivElement>>;
+
+declare const STATUS_MAP: {
+    readonly success: "success";
+    readonly healthy: "success";
+    readonly running: "success";
+    readonly ready: "success";
+    readonly active: "success";
+    readonly complete: "success";
+    readonly connected: "success";
+    readonly warning: "warning";
+    readonly degraded: "warning";
+    readonly slow: "warning";
+    readonly danger: "danger";
+    readonly error: "danger";
+    readonly failed: "danger";
+    readonly unhealthy: "danger";
+    readonly critical: "danger";
+    readonly disconnected: "danger";
+    readonly info: "info";
+    readonly pending: "info";
+    readonly waiting: "info";
+    readonly building: "info";
+    readonly syncing: "info";
+    readonly neutral: "neutral";
+    readonly unknown: "neutral";
+    readonly idle: "neutral";
+    readonly stopped: "neutral";
+};
+
+export declare const StatusBar: StatusBarCompound;
+
+declare type StatusBarCompound = typeof StatusBarRoot & {
+    Section: typeof StatusBarSection;
+    Item: typeof StatusBarItem;
+    Indicator: typeof StatusBarIndicator;
+    Progress: typeof StatusBarProgress;
+    IconItem: typeof StatusBarIconItem;
+    Separator: typeof StatusBarSeparator;
+};
+
+declare const StatusBarIconItem: ForwardRefExoticComponent<StatusBarIconItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface StatusBarIconItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    icon: ReactNode;
+    onClick?: () => void;
+    active?: boolean;
+    color?: ComponentColor;
+    children: ReactNode;
+}
+
+declare const StatusBarIndicator: ForwardRefExoticComponent<StatusBarIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface StatusBarIndicatorProps extends Omit<StatusDotProps, 'size'> {
+}
+
+declare const StatusBarItem: ForwardRefExoticComponent<StatusBarItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface StatusBarItemProps extends HTMLAttributes<HTMLDivElement> {
+    onClick?: () => void;
+    active?: boolean;
+    children: ReactNode;
+}
+
+declare const StatusBarProgress: ForwardRefExoticComponent<StatusBarProgressProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface StatusBarProgressProps extends Omit<ProgressProps, 'size'> {
+    label?: ReactNode;
+}
+
+export declare interface StatusBarProps extends HTMLAttributes<HTMLDivElement> {
+    size?: ComponentSize;
+}
+
+declare const StatusBarRoot: ForwardRefExoticComponent<StatusBarProps & RefAttributes<HTMLDivElement>>;
+
+declare const StatusBarSection: ForwardRefExoticComponent<StatusBarSectionProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface StatusBarSectionProps extends HTMLAttributes<HTMLDivElement> {
+    align?: 'start' | 'center' | 'end';
+    children: ReactNode;
+}
+
+declare const StatusBarSeparator: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+export declare type StatusColor = 'success' | 'warning' | 'danger' | 'info' | 'neutral';
+
+export declare const StatusDot: ForwardRefExoticComponent<StatusDotProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface StatusDotProps extends HTMLAttributes<HTMLSpanElement> {
+    status?: StatusDotStatus;
+    label?: string;
+    pulse?: boolean;
+    /** Controls the visual intensity of the pulse animation. */
+    pulseIntensity?: StatusDotPulseIntensity;
+    size?: 'sm' | 'md' | 'lg';
+}
+
+export declare type StatusDotPulseIntensity = 'subtle' | 'default' | 'strong';
+
+export declare type StatusDotStatus = 'success' | 'warning' | 'danger' | 'info' | 'neutral' | 'pending';
+
+/**
+ * Maps a semantic status string to a component color.
+ * Case-insensitive. Unknown values default to 'neutral'.
+ */
+export declare function statusToColor(status: string): StatusColor;
+
+export declare type StatusValue = keyof typeof STATUS_MAP;
+
+export declare const Stepper: StepperCompound;
+
+declare type StepperCompound = typeof StepperRoot & {
+    Step: typeof StepperStep;
+};
+
+export declare type StepperOrientation = 'horizontal' | 'vertical';
+
+export declare interface StepperProps extends HTMLAttributes<HTMLDivElement> {
+    /** 0-indexed current step. */
+    activeStep: number;
+    /** Layout direction. @default 'horizontal' */
+    orientation?: StepperOrientation;
+}
+
+declare const StepperRoot: ForwardRefExoticComponent<StepperProps & RefAttributes<HTMLDivElement>>;
+
+declare const StepperStep: ForwardRefExoticComponent<StepProps & InjectedStepProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface StepProps extends HTMLAttributes<HTMLDivElement> {
+    /** Primary text shown next to the step indicator. */
+    label: string;
+    /** Secondary text below the label. */
+    description?: string;
+    /** Custom icon to replace the step number. */
+    icon?: ReactNode;
+    /** Show the step in an error state. */
+    error?: boolean;
+    /** Override the auto-completion detection. */
+    completed?: boolean;
+    /** Mark the step as disabled (muted, non-interactive). */
+    disabled?: boolean;
+}
+
+export declare const Strong: <C extends StrongElement = "strong">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+declare type StrongElement = 'strong' | 'span';
+
+export declare type StrongProps<E extends StrongElement = StrongElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare interface StyledComponentProps {
+    variant?: ComponentVariant;
+    color?: ComponentColor;
+    size?: ComponentSize;
+}
+
+export declare type SurfaceElevation = 0 | 1 | 2 | 3;
+
+export declare type SurfaceType = 'base' | 'default' | 'raised' | 'overlay' | 'inset' | 'elevated';
+
+export declare const Switch: SwitchCompound;
+
+declare const SwitchBase: ForwardRefExoticComponent<SwitchProps & RefAttributes<HTMLElement>>;
+
+declare type SwitchCompound = typeof SwitchBase & {
+    Root: typeof SwitchRoot;
+    Thumb: typeof SwitchThumb;
+    Field: typeof SwitchField;
+    Label: typeof SwitchLabel;
+    Description: typeof SwitchDescription;
+};
+
+declare const SwitchDescription: ForwardRefExoticComponent<SwitchDescriptionProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type SwitchDescriptionProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const SwitchField: ForwardRefExoticComponent<SwitchFieldProps & RefAttributes<HTMLLabelElement>>;
+
+export declare type SwitchFieldProps = HTMLAttributes<HTMLLabelElement>;
+
+declare const SwitchLabel: ForwardRefExoticComponent<SwitchLabelProps & RefAttributes<HTMLSpanElement>>;
+
+export declare type SwitchLabelProps = HTMLAttributes<HTMLSpanElement>;
+
+export declare interface SwitchProps extends Omit<SwitchRootProps, 'children'> {
+    children?: ReactNode;
+    description?: ReactNode;
+    thumb?: ReactNode;
+    thumbProps?: Omit<SwitchThumbProps, 'children'>;
+    labelPosition?: 'start' | 'end';
+    layout?: 'inline' | 'spread';
+}
+
+declare const SwitchRoot: ForwardRefExoticComponent<SwitchRootProps & RefAttributes<HTMLElement>>;
+
+export declare interface SwitchRootProps extends Omit<ComponentPropsWithoutRef<typeof Switch_2.Root>, 'color'>, StyledComponentProps {
+}
+
+declare const SwitchThumb: ForwardRefExoticComponent<SwitchThumbProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface SwitchThumbProps extends Omit<ComponentPropsWithoutRef<typeof Switch_2.Thumb>, 'color'>, StyledComponentProps {
+}
+
+export declare type TabDescriptor = {
+    id: TabId;
+    title: string;
+    icon?: ReactNode;
+    dirty?: boolean;
+    disabled?: boolean;
+    closable?: boolean;
+    pinned?: boolean;
+    groupId?: TabGroupId | null;
+    payload?: unknown;
+};
+
+export declare function TabDragBrokerProvider({ children, onCancel }: TabDragBrokerProviderProps): JSX.Element;
+
+declare interface TabDragBrokerProviderProps {
+    children: ReactNode;
+    onCancel?: (session: TabDragSession) => void;
+}
+
+declare interface TabDragBrokerValue {
+    activeSession: TabDragSession | null;
+    beginSession: (session: TabDragSession, clientX: number, clientY: number) => void;
+    cancelSession: () => void;
+    /** Clears the session without calling onCancel (used when reverting mid-drag). */
+    clearSession: () => void;
+    registerDropZone: (reg: DropZoneRegistration) => void;
+    unregisterDropZone: (instanceId: string) => void;
+    hoverInstanceId: string | null;
+    pointerX: number;
+    pointerY: number;
+}
+
+declare interface TabDragSession {
+    tab: TabDescriptor;
+    sourceInstanceId: string;
+    ghostStyle?: React.CSSProperties;
+}
+
+export declare type TabGroupDescriptor = {
+    id: TabGroupId;
+    title?: string;
+    color?: string;
+    fg?: string;
+    collapsed?: boolean;
+};
+
+export declare type TabGroupId = string;
+
+export declare type TabId = string;
+
+export declare const Table: TableCompound;
+
+declare const TableBody: ForwardRefExoticComponent<TableBodyProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare type TableBodyProps = HTMLAttributes<HTMLTableSectionElement>;
+
+declare const TableCaption: ForwardRefExoticComponent<TableCaptionProps & RefAttributes<HTMLTableCaptionElement>>;
+
+export declare interface TableCaptionProps extends Omit<HTMLAttributes<HTMLTableCaptionElement>, 'color'> {
+    side?: 'top' | 'bottom';
+}
+
+declare const TableCell: ForwardRefExoticComponent<TableCellProps & RefAttributes<HTMLTableCellElement>>;
+
+export declare type TableCellAlign = 'left' | 'center' | 'right';
+
+declare interface TableCellBaseProps {
+    align?: TableCellAlign;
+    numeric?: boolean;
+    mono?: boolean;
+    truncate?: boolean;
+    tone?: TableCellTone;
+}
+
+export declare interface TableCellProps extends Omit<TdHTMLAttributes<HTMLTableCellElement>, 'color' | 'align'>, TableCellBaseProps {
+}
+
+export declare type TableCellTone = 'default' | 'muted' | 'subtle' | 'brand' | 'success' | 'warning' | 'danger';
+
+declare type TableCompound = typeof TableRoot & {
+    Root: typeof TableRoot;
+    Container: typeof TableContainer;
+    Head: typeof TableHead;
+    Body: typeof TableBody;
+    Footer: typeof TableFooter;
+    Row: typeof TableRow;
+    Cell: typeof TableCell;
+    HeaderCell: typeof TableHeaderCell;
+    Caption: typeof TableCaption;
+};
+
+declare const TableContainer: ForwardRefExoticComponent<TableContainerProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface TableContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    maxHeight?: number | string;
+}
+
+declare const TableFooter: ForwardRefExoticComponent<TableFooterProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare type TableFooterProps = HTMLAttributes<HTMLTableSectionElement>;
+
+declare const TableHead: ForwardRefExoticComponent<TableHeadProps & RefAttributes<HTMLTableSectionElement>>;
+
+declare const TableHeaderCell: ForwardRefExoticComponent<TableHeaderCellProps & RefAttributes<HTMLTableCellElement>>;
+
+export declare interface TableHeaderCellProps extends Omit<ThHTMLAttributes<HTMLTableCellElement>, 'color' | 'align'>, TableCellBaseProps {
+}
+
+export declare type TableHeadProps = HTMLAttributes<HTMLTableSectionElement>;
+
+export declare type TableLayout = 'auto' | 'fixed';
+
+export declare interface TableProps extends Omit<TableHTMLAttributes<HTMLTableElement>, 'color'>, StyledComponentProps {
+    layout?: TableLayout;
+    striped?: boolean;
+    hoverable?: boolean;
+    stickyHeader?: boolean;
+}
+
+declare const TableRoot: ForwardRefExoticComponent<TableProps & RefAttributes<HTMLTableElement>>;
+
+declare const TableRow: ForwardRefExoticComponent<TableRowProps & RefAttributes<HTMLTableRowElement>>;
+
+export declare interface TableRowProps extends HTMLAttributes<HTMLTableRowElement> {
+    selected?: boolean;
+    interactive?: boolean;
+}
+
+export declare const Tabs: TabsCompound;
+
+declare type TabsCompound = typeof TabsRoot & {
+    Root: typeof TabsRoot;
+    List: typeof TabsList;
+    Tab: typeof TabsTab;
+    Panel: typeof TabsPanel;
+    Indicator: typeof TabsIndicator;
+};
+
+export declare type TabSegments = {
+    pinned: TabDescriptor[];
+    groups: Array<{
+        group: TabGroupDescriptor;
+        tabs: TabDescriptor[];
+    }>;
+    ungrouped: TabDescriptor[];
+};
+
+declare const TabsIndicator: ForwardRefExoticComponent<Omit<TabsIndicatorProps_2, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare type TabsIndicatorProps = Tabs_2.Indicator.Props;
+
+declare const TabsList: ForwardRefExoticComponent<Omit<TabsListProps_2, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare type TabsListProps = Tabs_2.List.Props;
+
+declare const TabsPanel: ForwardRefExoticComponent<Omit<TabsPanelProps_2, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare type TabsPanelProps = Tabs_2.Panel.Props;
+
+declare const TabsRoot: ForwardRefExoticComponent<Omit<TabsRootProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare interface TabsRootProps extends Tabs_2.Root.Props, Omit<StyledComponentProps, 'variant'> {
+    variant?: TabsVariant;
+}
+
+declare const TabsTab: ForwardRefExoticComponent<Omit<TabsTabProps, "ref"> & RefAttributes<HTMLButtonElement>>;
+
+export declare type TabsTabProps = Tabs_2.Tab.Props & {
+    /** Slot rendered after the tab label (e.g. Badge, icon, count) */
+    endDecorator?: ReactNode;
+};
+
+declare type TabsVariant = 'solid' | 'soft' | 'outline' | 'ghost' | 'flat';
+
+export declare const TagInput: ForwardRefExoticComponent<TagInputProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface TagInputProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Current tag values (controlled). */
+    value: string[];
+    /** Called whenever the tag list changes. */
+    onChange: (tags: string[]) => void;
+    /** Placeholder shown when there are no tags and the input is empty. */
+    placeholder?: string;
+    /** Character or pattern used to split input into tags. Defaults to `","`. */
+    delimiter?: string | RegExp;
+    /** Maximum number of tags allowed. */
+    max?: number;
+    /** Whether duplicate tags are permitted. Defaults to `false`. */
+    allowDuplicates?: boolean;
+    /** Optional validation function; only tags for which this returns `true` are added. */
+    validate?: (tag: string) => boolean;
+    /** Control size. */
+    size?: ComponentSize;
+    /** Disables the entire input. */
+    disabled?: boolean;
+    /** Props forwarded to the inner `<input>` element (e.g. id, name, aria-*, autoComplete). */
+    inputProps?: React.InputHTMLAttributes<HTMLInputElement>;
+}
+
+declare const Text_2: TextComponent;
+export { Text_2 as Text }
+
+export declare const TextArea: TextAreaCompound;
+
+declare type TextAreaCompound = typeof TextAreaRoot & {
+    Root: typeof TextAreaRoot;
+    Label: typeof TextAreaLabel;
+    Control: typeof TextAreaControl;
+    Description: typeof TextAreaDescription;
+    Error: typeof TextAreaError;
+};
+
+declare const TextAreaControl: ForwardRefExoticComponent<TextAreaControlProps & RefAttributes<HTMLTextAreaElement>>;
+
+export declare interface TextAreaControlProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'size' | 'color'>, StyledComponentProps {
+    mono?: boolean;
+    resize?: CSSProperties['resize'];
+}
+
+declare const TextAreaDescription: ForwardRefExoticComponent<Omit<FieldDescriptionProps, "ref"> & RefAttributes<HTMLParagraphElement>>;
+
+export declare type TextAreaDescriptionProps = Field.Description.Props;
+
+declare const TextAreaError: ForwardRefExoticComponent<Omit<FieldErrorProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare type TextAreaErrorProps = Field.Error.Props;
+
+declare const TextAreaLabel: ForwardRefExoticComponent<Omit<FieldLabelProps, "ref"> & RefAttributes<HTMLElement>>;
+
+export declare type TextAreaLabelProps = Field.Label.Props;
+
+declare const TextAreaRoot: ForwardRefExoticComponent<Omit<TextAreaRootProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare interface TextAreaRootProps extends Field.Root.Props, StyledComponentProps {
+}
+
+declare type TextComponent = <C extends TextElement = 'span'>(props: TextProps<C> & {
+    ref?: PolymorphicRef<C>;
+}) => ReactElement | null;
+
+declare type TextElement = 'span' | 'p' | 'div' | 'label';
+
+export declare const TextField: TextFieldCompound;
+
+declare type TextFieldCompound = typeof TextFieldRoot & {
+    Root: typeof TextFieldRoot;
+    Label: typeof TextFieldLabel;
+    Control: typeof TextFieldControl;
+    Description: typeof TextFieldDescription;
+    Error: typeof TextFieldError;
+};
+
+declare const TextFieldControl: ForwardRefExoticComponent<Omit<FieldControlProps, "ref"> & RefAttributes<HTMLInputElement>>;
+
+export declare type TextFieldControlProps = Field.Control.Props;
+
+declare const TextFieldDescription: ForwardRefExoticComponent<Omit<FieldDescriptionProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare type TextFieldDescriptionProps = Field.Description.Props;
+
+declare const TextFieldError: ForwardRefExoticComponent<Omit<FieldErrorProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare type TextFieldErrorProps = Field.Error.Props;
+
+declare const TextFieldLabel: ForwardRefExoticComponent<Omit<FieldLabelProps, "ref"> & RefAttributes<HTMLLabelElement>>;
+
+export declare type TextFieldLabelProps = Field.Label.Props;
+
+declare const TextFieldRoot: ForwardRefExoticComponent<Omit<TextFieldRootProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare interface TextFieldRootProps extends Field.Root.Props, StyledComponentProps {
+}
+
+declare interface TextOwnProps extends TypographyBaseProps, TruncationProps {
+    weight?: TypographyWeight;
+    mono?: boolean;
+}
+
+export declare type TextProps<C extends TextElement = TextElement> = PolymorphicComponentProps<C, TextOwnProps>;
+
+export declare interface ThemeContextValue extends ThemeState {
+    setTheme: (theme: ThemeMode) => void;
+    setDensity: (density: ThemeDensity) => void;
+    setMotion: (motion: ThemeMotion) => void;
+}
+
+export declare type ThemeDensity = 'compact' | 'comfortable';
+
+export declare type ThemeMode = 'dark' | 'light' | 'high-contrast-dark' | 'high-contrast-light' | 'obsidian' | 'carbon' | 'void';
+
+export declare type ThemeMotion = 'normal' | 'reduced';
+
+export declare function ThemeProvider({ children, initialTheme, initialDensity, initialMotion, persist, }: ThemeProviderProps): JSX.Element;
+
+export declare interface ThemeProviderProps extends PropsWithChildren {
+    initialTheme?: ThemeMode;
+    initialDensity?: ThemeDensity;
+    initialMotion?: ThemeMotion;
+    persist?: boolean;
+}
+
+export declare interface ThemeState {
+    theme: ThemeMode;
+    density: ThemeDensity;
+    motion: ThemeMotion;
+}
+
+export declare const ThemeSwitcher: NamedExoticComponent<ThemeSwitcherProps>;
+
+export declare interface ThemeSwitcherProps {
+    className?: string;
+}
+
+export declare const Timeline: TimelineCompound;
+
+declare type TimelineCompound = typeof TimelineRoot & {
+    Item: typeof TimelineItem;
+    Group: typeof TimelineGroup;
+};
+
+declare const TimelineGroup: ForwardRefExoticComponent<TimelineGroupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface TimelineGroupProps extends HTMLAttributes<HTMLDivElement> {
+    label: ReactNode;
+    children: ReactNode;
+}
+
+declare const TimelineItem: ForwardRefExoticComponent<TimelineItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface TimelineItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    timestamp?: ReactNode;
+    icon?: ReactNode;
+    color?: ComponentColor;
+    /** Collapsible content revealed when item is expanded */
+    details?: ReactNode;
+    /** Default expanded state (uncontrolled) */
+    defaultExpanded?: boolean;
+    /** Controlled expanded state */
+    expanded?: boolean;
+    /** Called when expanded state changes */
+    onExpandedChange?: (expanded: boolean) => void;
+    children: ReactNode;
+}
+
+export declare interface TimelineProps extends HTMLAttributes<HTMLDivElement> {
+    size?: ComponentSize;
+    children: ReactNode;
+}
+
+declare const TimelineRoot: ForwardRefExoticComponent<TimelineProps & RefAttributes<HTMLDivElement>>;
+
+declare interface ToastContextValue {
+    toast: (message: string, options?: ToastOptions) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+    promise: <T>(promise: Promise<T>, messages: ToastPromiseMessages<T>) => Promise<T>;
+}
+
+export declare interface ToastOptions {
+    /** Severity colour band. @default 'info' */
+    severity?: ToastSeverity;
+    /** Auto-dismiss in ms. 0 = persistent. @default 5000 */
+    duration?: number;
+    /** Optional action button rendered inside the toast. */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** Optional title displayed above the message. */
+    title?: string;
+}
+
+export declare type ToastPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
+
+export declare interface ToastPromiseMessages<T> {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((err: unknown) => string);
+}
+
+export declare const ToastProvider: ForwardRefExoticComponent<ToastProviderProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ToastProviderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Screen corner for the toast container. @default 'bottom-right' */
+    position?: ToastPosition;
+    /** Maximum visible toasts before older ones are dismissed. @default 5 */
+    maxVisible?: number;
+    /** Background surface level for toasts. @default 'raised' */
+    surface?: SurfaceType;
+    /** Shadow elevation level. @default 2 */
+    elevation?: SurfaceElevation;
+    children: ReactNode;
+}
+
+export declare type ToastSeverity = 'success' | 'warning' | 'danger' | 'info';
+
+export declare const ToggleButton: ForwardRefExoticComponent<Omit<ToggleButtonProps, "ref"> & RefAttributes<HTMLButtonElement>>;
+
+export declare const ToggleButtonGroup: ToggleButtonGroupCompound;
+
+declare type ToggleButtonGroupCompound = typeof ToggleButtonGroupRoot & {
+    Item: typeof ToggleButtonGroupItem;
+};
+
+declare const ToggleButtonGroupItem: ForwardRefExoticComponent<Omit<ToggleButtonGroupItemProps, "ref"> & RefAttributes<HTMLButtonElement>>;
+
+export declare interface ToggleButtonGroupItemProps extends Omit<ToggleButtonProps, 'value'> {
+    value: string;
+}
+
+export declare interface ToggleButtonGroupProps extends Omit<ToggleGroup.Props<string>, 'color'>, StyledComponentProps {
+    attached?: boolean;
+}
+
+declare const ToggleButtonGroupRoot: ForwardRefExoticComponent<Omit<ToggleButtonGroupProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare interface ToggleButtonProps extends Omit<Toggle.Props<string>, 'color'>, StyledComponentProps {
+    /** Render as a square button (same sizing as IconButton). */
+    square?: boolean;
+    startDecorator?: ReactNode;
+    endDecorator?: ReactNode;
+}
+
+export declare const Toolbar: ToolbarCompound;
+
+declare type ToolbarCompound = typeof ToolbarRoot & {
+    Group: typeof ToolbarGroup;
+};
+
+declare const ToolbarGroup: ForwardRefExoticComponent<ToolbarGroupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ToolbarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Show a vertical separator before this group. */
+    separator?: boolean;
+}
+
+export declare interface ToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Size of the toolbar – controls height. */
+    size?: ComponentSize;
+}
+
+declare const ToolbarRoot: ForwardRefExoticComponent<ToolbarProps & RefAttributes<HTMLDivElement>>;
+
+export declare const Tooltip: TooltipCompound;
+
+declare const TooltipArrow: ForwardRefExoticComponent<TooltipArrowProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface TooltipArrowProps extends Omit<ComponentPropsWithoutRef<typeof Tooltip_2.Arrow>, 'color'>, StyledComponentProps {
+}
+
+declare type TooltipCompound = typeof TooltipRoot & {
+    Root: typeof TooltipRoot;
+    Provider: typeof Tooltip_2.Provider;
+    Trigger: typeof TooltipTrigger;
+    Portal: typeof TooltipPortal;
+    Positioner: typeof TooltipPositioner;
+    Popup: typeof TooltipPopup;
+    Arrow: typeof TooltipArrow;
+    Viewport: typeof TooltipViewport;
+    Handle: typeof Tooltip_2.Handle;
+    createHandle: typeof Tooltip_2.createHandle;
+};
+
+declare const TooltipPopup: ForwardRefExoticComponent<TooltipPopupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface TooltipPopupProps extends Omit<ComponentPropsWithoutRef<typeof Tooltip_2.Popup>, 'color'>, StyledComponentProps {
+}
+
+declare const TooltipPortal: ForwardRefExoticComponent<Omit<Omit<TooltipPortalProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare const TooltipPositioner: ForwardRefExoticComponent<Omit<Omit<TooltipPositionerProps, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare function TooltipRoot<Payload>({ variant, color, size, lazy, defaultOpen, open, onOpenChange, ...props }: TooltipRootProps<Payload>): JSX.Element;
+
+declare namespace TooltipRoot {
+    var displayName: string;
+}
+
+export declare type TooltipRootProps<Payload = unknown> = Omit<Tooltip_2.Root.Props<Payload>, 'color'> & StyledComponentProps & {
+    /** Defer content rendering until the tooltip first opens. Default: false */
+    lazy?: boolean;
+};
+
+declare const TooltipTrigger: ForwardRefExoticComponent<TooltipTriggerProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface TooltipTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Tooltip_2.Trigger>, 'color'>, StyledComponentProps {
+}
+
+declare const TooltipViewport: ForwardRefExoticComponent<Omit<Omit<Tooltip_2.Viewport.Props, "ref"> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare interface TreeActionsContextValue {
+    select: (key: Key_3) => void;
+    deselect: (key: Key_3) => void;
+    toggle: (key: Key_3) => void;
+    selectRange: (toKey: Key_3) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+    setActiveKey: (key: Key_3 | null) => void;
+    expand: (key: Key_3) => void;
+    collapse: (key: Key_3) => void;
+    toggleExpanded: (key: Key_3) => void;
+    expandAll: () => void;
+    /** Non-blocking alternative to expandAll for very large trees (10k+ nodes). */
+    expandAllAsync: () => Promise<void>;
+    collapseAll: () => void;
+}
+
+declare interface TreeConfigContextValue {
+    listId: string;
+    selectionMode: SelectionMode_3;
+    selectionBehavior: SelectionBehavior_2;
+    density: ListDensity_3;
+    typeahead: boolean;
+    loopFocus: boolean;
+    virtualized: boolean;
+    indentation: number;
+    showBranchConnectors: boolean;
+}
+
+export declare interface TreeItemState {
+    isSelected: boolean;
+    isActive: boolean;
+    isDisabled: boolean;
+    isExpanded: boolean;
+    isBranch: boolean;
+    isLoading: boolean;
+    depth: number;
+}
+
+export declare const TreeList: TreeListCompound;
+
+declare type TreeListCompound = typeof TreeListRoot & {
+    Root: typeof TreeListRoot;
+    Viewport: typeof TreeListViewport;
+    Item: typeof TreeListItem;
+    ItemIndent: typeof TreeListItemIndent;
+    ItemToggle: typeof TreeListItemToggle;
+    ItemIcon: typeof TreeListItemIcon;
+    ItemLabel: typeof TreeListItemLabel;
+    ItemDescription: typeof TreeListItemDescription;
+    ItemMeta: typeof TreeListItemMeta;
+    ItemBadge: typeof TreeListItemBadge;
+    ItemActions: typeof TreeListItemActions;
+    Empty: typeof TreeListEmpty;
+    Loading: typeof TreeListLoading;
+};
+
+declare const TreeListEmpty: ForwardRefExoticComponent<TreeListEmptyProps & RefAttributes<HTMLDivElement>>;
+
+declare interface TreeListEmptyProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+declare const TreeListItem: ForwardRefExoticComponent<TreeListItemProps & RefAttributes<HTMLDivElement>>;
+
+declare const TreeListItemActions: ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+
+declare const TreeListItemBadge: ForwardRefExoticComponent<TreeListItemBadgeProps & RefAttributes<HTMLSpanElement>>;
+
+declare interface TreeListItemBadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    color?: ComponentColor;
+}
+
+declare const TreeListItemDescription: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const TreeListItemIcon: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const TreeListItemIndent: ForwardRefExoticComponent<TreeListItemIndentProps & RefAttributes<HTMLSpanElement>>;
+
+declare interface TreeListItemIndentProps extends HTMLAttributes<HTMLSpanElement> {
+    depth?: number;
+    ancestorIsLast?: boolean[];
+    isLastChild?: boolean;
+}
+
+declare const TreeListItemLabel: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+declare const TreeListItemMeta: ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+
+export declare interface TreeListItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    itemKey: Key_3;
+    disabled?: boolean;
+    textValue?: string;
+    children: ReactNode;
+}
+
+declare const TreeListItemToggle: ForwardRefExoticComponent<TreeListItemToggleProps & RefAttributes<HTMLButtonElement>>;
+
+declare interface TreeListItemToggleProps extends HTMLAttributes<HTMLButtonElement> {
+    itemKey?: Key_3;
+}
+
+declare const TreeListLoading: ForwardRefExoticComponent<TreeListLoadingProps & RefAttributes<HTMLDivElement>>;
+
+declare interface TreeListLoadingProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+declare const TreeListRoot: <TItem>(props: TreeListRootProps<TItem> & {
+    ref?: Ref<HTMLDivElement>;
+}) => ReactNode;
+
+export declare interface TreeListRootProps<TItem = unknown> extends Omit<HTMLAttributes<HTMLDivElement>, 'color'>, StyledComponentProps {
+    items: readonly TItem[];
+    itemKey: (item: TItem) => Key_3;
+    /** Return the children array, or `undefined` if children haven't been loaded yet.
+     *  An empty array `[]` means "loaded, no children" and will NOT trigger `loadChildren`. */
+    getChildren: (item: TItem) => readonly TItem[] | undefined;
+    isBranch?: (item: TItem) => boolean;
+    getTextValue?: (item: TItem) => string;
+    renderItem: (item: TItem, node: TreeNodeMeta) => ReactNode;
+    expandedKeys?: ReadonlySet<Key_3>;
+    defaultExpandedKeys?: Iterable<Key_3>;
+    onExpandedKeysChange?: (keys: ReadonlySet<Key_3>) => void;
+    /** Called when a branch is expanded whose `getChildren` returns `undefined` (not yet loaded).
+     *  Not called for branches that return `[]` (loaded but empty). */
+    loadChildren?: (key: Key_3, item: TItem) => Promise<void>;
+    onLoadError?: (error: unknown, key: Key_3, item: TItem) => void;
+    selectionMode?: SelectionMode_3;
+    selectionBehavior?: SelectionBehavior_2;
+    selectedKeys?: ReadonlySet<Key_3>;
+    defaultSelectedKeys?: Iterable<Key_3>;
+    onSelectedKeysChange?: (keys: ReadonlySet<Key_3>) => void;
+    activeKey?: Key_3 | null;
+    defaultActiveKey?: Key_3 | null;
+    onActiveKeyChange?: (key: Key_3 | null) => void;
+    disabledKeys?: Iterable<Key_3>;
+    loopFocus?: boolean;
+    typeahead?: boolean;
+    density?: ListDensity_3;
+    virtualized?: boolean;
+    overscan?: number;
+    estimatedItemSize?: number;
+    filterText?: string;
+    defaultFilterText?: string;
+    onFilterTextChange?: (filterText: string) => void;
+    filterFn?: (item: TItem, filterText: string) => boolean;
+    indentation?: number;
+    showBranchConnectors?: boolean;
+    loading?: boolean;
+    error?: ReactNode;
+    children?: ReactNode;
+}
+
+declare const TreeListViewport: ForwardRefExoticComponent<TreeListViewportProps & RefAttributes<HTMLDivElement>>;
+
+declare type TreeListViewportProps = HTMLAttributes<HTMLDivElement>;
+
+export declare interface TreeNodeMeta {
+    key: Key_3;
+    depth: number;
+    parentKey: Key_3 | null;
+    isBranch: boolean;
+    isExpanded: boolean;
+    isLoading: boolean;
+    isLastChild: boolean;
+    ancestorIsLast: boolean[];
+}
+
+declare interface TreeStore {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => TreeStoreSnapshot;
+    getItemState: (key: Key_3) => TreeItemState;
+    getNodeMeta: (key: Key_3) => TreeNodeMeta | undefined;
+    getFlatNodes: () => readonly FlatNode[];
+    setSelectedKeys: (keys: Set<Key_3>, silent?: boolean) => void;
+    setActiveKey: (key: Key_3 | null, silent?: boolean) => void;
+    setExpandedKeys: (keys: Set<Key_3>, silent?: boolean) => void;
+    setLoadingKey: (key: Key_3, loading: boolean, silent?: boolean) => void;
+    setFlatNodes: (nodes: FlatNode[], silent?: boolean) => void;
+    registerTextValue: (key: Key_3, textValue: string) => void;
+    getTextValue: (key: Key_3) => string | undefined;
+    getRegisteredKeys: () => Key_3[];
+    /** Rebuild snapshot and notify listeners. Call from useEffect after silent updates. */
+    emit: () => void;
+}
+
+declare interface TreeStoreSnapshot {
+    selectedKeys: ReadonlySet<Key_3>;
+    activeKey: Key_3 | null;
+    disabledKeys: ReadonlySet<Key_3>;
+    expandedKeys: ReadonlySet<Key_3>;
+    loadingKeys: ReadonlySet<Key_3>;
+    flattenedKeys: readonly Key_3[];
+    visibleCount: number;
+}
+
+export declare interface TruncationProps {
+    truncate?: TypographyTruncate;
+}
+
+export declare const Typography: TypographyCompound;
+
+export declare interface TypographyBaseProps {
+    size?: ComponentSize;
+    tone?: TypographyTone;
+}
+
+declare type TypographyCompound = typeof Text_2 & {
+    Heading: typeof Heading;
+    Blockquote: typeof Blockquote;
+    Caption: typeof Caption;
+    Code: typeof Code;
+    Em: typeof Em;
+    Link: typeof Link;
+    Overline: typeof Overline;
+    Quote: typeof Quote;
+    Strong: typeof Strong;
+    Underline: typeof Underline;
+    Hotkey: typeof Hotkey;
+};
+
+export declare type TypographyTone = 'default' | 'muted' | 'subtle' | 'brand' | 'success' | 'warning' | 'danger';
+
+export declare type TypographyTruncate = boolean | number;
+
+export declare type TypographyWeight = 'regular' | 'medium' | 'semibold';
+
+export declare const Underline: <C extends UnderlineElement = "u">(props: TypographyBaseProps & TruncationProps & {
+    as?: C | undefined;
+} & Omit<PropsWithoutRef<ComponentProps<C>>, "color" | "as" | "truncate" | keyof TypographyBaseProps> & {
+    ref?: PolymorphicRef<C> | undefined;
+}) => ReactElement | null;
+
+declare type UnderlineElement = 'u' | 'span';
+
+export declare type UnderlineProps<E extends UnderlineElement = UnderlineElement> = PolymorphicComponentProps<E, TypographyBaseProps & TruncationProps>;
+
+export declare function useCollapsible(): CollapsibleContextValue;
+
+/**
+ * Provides a DnD end handler that reorders columns.
+ * Used with @dnd-kit/core DndContext in the DataTable root.
+ */
+export declare function useColumnDnd(table: Table_2<any>): {
+    handleDragEnd: (event: DragEndEvent) => void;
+};
+
+/**
+ * Computes CSS custom properties for all column widths.
+ * Applied at the root table element so cells reference them via
+ * `width: calc(var(--header-{id}-size) * 1px)` without per-cell inline styles.
+ *
+ * Only recomputes when columnSizing or columnSizingInfo changes.
+ */
+export declare function useColumnSizeVars(table: Table_2<any>): Record<string, number>;
+
+export declare function useCommandListActions(): CommandListActionsContextValue;
+
+export declare function useCommandListConfig(): CommandListConfigContextValue;
+
+/**
+ * Per-item hook that subscribes to only this item's state slice.
+ * Uses useSyncExternalStore so the item only re-renders when
+ * its own isActive/isDisabled changes.
+ */
+export declare function useCommandListItem(store: CommandListStore, key: Key_2): CommandListItemState;
+
+export declare function useCommandListStoreContext(): CommandListStore;
+
+export declare function useDataTable<TData = any>(options: UseDataTableOptions<TData>): Table_2<TData>;
+
+export declare function useDataTableContext(): DataTableContextValue;
+
+export declare interface UseDataTableOptions<TData> {
+    data: TData[];
+    columns: ColumnDef_2<TData, unknown>[];
+    features?: DataTableFeatures;
+    initialState?: Partial<TableState>;
+    getRowId?: (row: TData, index: number) => string;
+    getSubRows?: (row: TData) => TData[] | undefined;
+    getRowCanExpand?: (row: {
+        original: TData;
+        depth: number;
+    }) => boolean;
+    persistenceKey?: string;
+    onRowSelectionChange?: (selection: RowSelectionState) => void;
+    onSortingChange?: (sorting: SortingState) => void;
+    onColumnVisibilityChange?: (visibility: VisibilityState) => void;
+    onColumnOrderChange?: (order: ColumnOrderState) => void;
+    onColumnSizingChange?: (sizing: ColumnSizingState) => void;
+    onExpandedChange?: (expanded: ExpandedState) => void;
+    onPaginationChange?: (pagination: PaginationState) => void;
+    onColumnPinningChange?: (pinning: ColumnPinningState) => void;
+    defaultColumn?: Partial<ColumnDef_2<TData, unknown>>;
+    meta?: Record<string, unknown>;
+    enableMultiSort?: boolean;
+    manualSorting?: boolean;
+    manualFiltering?: boolean;
+    manualPagination?: boolean;
+    pageCount?: number;
+    globalFilterFn?: 'auto' | 'includesString' | 'includesStringSensitive';
+}
+
+/**
+ * Persists select table state to localStorage under the given key.
+ * Restores on mount. Only persists column sizing, visibility, order, and sorting.
+ */
+export declare function useDataTablePersistence(table: Table_2<any>, key: string | undefined): void;
+
+/**
+ * Returns a debounced version of the callback that only fires after `delay` ms
+ * of no invocations. Includes `cancel()` and `flush()` methods.
+ */
+export declare function useDebouncedCallback<TArgs extends unknown[], TReturn>(callback: (...args: TArgs) => TReturn, delay?: number): DebouncedFunction<TArgs, TReturn>;
+
+/**
+ * Returns a debounced version of the value that only updates after `delay` ms
+ * of no changes. The initial value is returned immediately without delay.
+ */
+export declare function useDebouncedValue<T>(value: T, delay?: number): T;
+
+/**
+ * Hook that registers any control with the EditableList field system.
+ * Works with `<input>`, `<select>`, `<textarea>`, or any custom component
+ * that exposes `{ value, focus() }`.
+ *
+ * Usage:
+ * ```tsx
+ * function MySelect({ name, defaultValue }) {
+ *   const { ref, error, setValue } = EditableList.useField(name, defaultValue);
+ *   return (
+ *     <select ref={ref} defaultValue={defaultValue} onChange={e => setValue(e.target.value)}>
+ *       <option value="a">A</option>
+ *       <option value="b">B</option>
+ *     </select>
+ *   );
+ * }
+ * ```
+ */
+declare function useEditableField(name: string, defaultValue?: string): UseEditableFieldResult;
+
+/** Return value of the `useEditableField` hook. */
+export declare interface UseEditableFieldResult {
+    /** Attach to your control's `ref` to register it with the field system. */
+    ref: RefCallback<FieldElement>;
+    /** Current error message for this field (undefined = no error). */
+    error: string | undefined;
+    /** Call when the control's value changes to keep the field system in sync. */
+    setValue: (value: string) => void;
+}
+
+export declare function useEditorTabsContext(): EditorTabsContextValue;
+
+export declare function useListActions(): ListActionsContextValue;
+
+export declare function useListConfig(): ListConfigContextValue;
+
+/**
+ * Per-item hook that subscribes to only this item's state slice.
+ * Uses useSyncExternalStore so the item only re-renders when
+ * its own isSelected/isActive/isDisabled changes.
+ */
+export declare function useListItem(store: ListStore, key: Key, textValue?: string): ItemState;
+
+export declare function useListStoreContext(): ListStore;
+
+/**
+ * Thin wrapper around @tanstack/react-virtual for list virtualization.
+ */
+export declare function useListVirtualizer({ count, scrollRef, overscan, estimatedItemSize, enabled, orientation, }: UseListVirtualizerOptions): UseListVirtualizerReturn;
+
+export declare interface UseListVirtualizerOptions {
+    count: number;
+    scrollRef: RefObject<HTMLDivElement | null>;
+    overscan?: number;
+    estimatedItemSize?: number;
+    enabled?: boolean;
+    orientation?: ListOrientation;
+}
+
+export declare interface UseListVirtualizerReturn {
+    virtualItems: VirtualItem[];
+    totalSize: number;
+    measureElement: (el: HTMLElement | null) => void;
+}
+
+export declare function useSortableTable<T>(options: UseSortableTableOptions<T>): UseSortableTableReturn<T>;
+
+export declare interface UseSortableTableOptions<T> {
+    data: T[];
+    defaultSort?: SortConfig;
+    columns: SortableColumnDef<T>[];
+}
+
+export declare interface UseSortableTableReturn<T> {
+    sortedData: T[];
+    sort: SortConfig;
+    onSort: (columnId: string) => void;
+    columns: SortableColumnDef<T>[];
+}
+
+export declare function useTabDragBroker(): TabDragBrokerValue | null;
+
+export declare function useTheme(): ThemeContextValue;
+
+export declare function useToast(): ToastContextValue;
+
+export declare function useTreeActions(): TreeActionsContextValue;
+
+export declare function useTreeConfig(): TreeConfigContextValue;
+
+/**
+ * Per-item hook that subscribes to only this item's state slice.
+ * Uses useSyncExternalStore so the item only re-renders when
+ * its own state changes.
+ *
+ * Unlike useListItem, this does NOT self-register — keys come from
+ * the flattener, not from DOM mount.
+ */
+export declare function useTreeItem(store: TreeStore, key: Key_3, textValue?: string): TreeItemState;
+
+export declare function useTreeStoreContext(): TreeStore;
+
+/** Validation function. Return a FieldErrors map (empty or all-undefined = valid). */
+export declare type ValidateItem = (key: Key, values: Record<string, string>) => FieldErrors | Promise<FieldErrors>;
+
+export { }