@owodesign/owoui 0.1.7-beta2 → 0.1.8

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { HTMLAttributes, ReactNode, ButtonHTMLAttributes, AnchorHTMLAttributes, ReactElement, ElementType, InputHTMLAttributes, TextareaHTMLAttributes } from 'react';
+import { HTMLAttributes, ReactNode, ButtonHTMLAttributes, AnchorHTMLAttributes, ReactElement, ElementType, InputHTMLAttributes, RefObject, TextareaHTMLAttributes } from 'react';
 
 type AvatarSize = 'xs' | 'sm' | 'md' | 'lg';
 type AvatarTone = 'neutral' | 'subtle';
@@ -45,6 +45,26 @@ type ButtonProps = ButtonElementProps | LinkElementProps;
 declare function buttonClassName({ className, }: Pick<ButtonProps, 'variant' | 'size' | 'loading' | 'className'>): string;
 declare function Button(props: ButtonProps): react_jsx_runtime.JSX.Element;
 
+type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface CheckboxProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    name?: string;
+    value?: string;
+    id?: string;
+    size?: CheckboxSize;
+    className?: string;
+    ariaLabel?: string;
+    children?: ReactNode;
+    'aria-describedby'?: string;
+}
+declare function Checkbox({ checked: checkedProp, defaultChecked, onCheckedChange, indeterminate, disabled, required, invalid, name, value, id, size, className, ariaLabel, children, 'aria-describedby': ariaDescribedBy, }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
 type CollapsiblePart = 'trigger' | 'content' | 'triggerInner' | 'triggerIcon' | 'triggerLabel' | 'triggerIndicator' | 'contentInner';
 interface CollapsibleRootProps extends HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
@@ -195,15 +215,32 @@ interface DrawerProps extends HTMLAttributes<HTMLElement> {
 }
 declare function Drawer({ as: Component, open, children, side, position, showBackdrop, onClose, closeLabel, backdropClassName, className, classNames, ...props }: DrawerProps): react_jsx_runtime.JSX.Element;
 
-type FieldPart = 'label' | 'help';
+type FieldPart = 'label' | 'description' | 'error' | 'help' | 'required';
 interface FieldProps extends HTMLAttributes<HTMLDivElement> {
     label: ReactNode;
+    description?: ReactNode;
+    error?: ReactNode;
     help?: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
     htmlFor?: string;
     children: ReactNode;
     classNames?: Partial<Record<FieldPart, string>>;
 }
-declare function Field({ label, help, htmlFor, children, className, classNames, ...props }: FieldProps): react_jsx_runtime.JSX.Element;
+declare function Field({ label, description, error, help, required, disabled, invalid, htmlFor, children, className, classNames, ...props }: FieldProps): react_jsx_runtime.JSX.Element;
+
+interface FieldContextValue {
+    /** Auto-generated control ID for htmlFor / id association. */
+    controlId: string;
+    /** Label element ID for controls that need aria-labelledby instead of htmlFor. */
+    labelId: string;
+    /** Space-separated IDs for aria-describedby (description + error slots). */
+    describedBy: string | undefined;
+    disabled: boolean;
+    invalid: boolean;
+    required: boolean;
+}
 
 type IconButtonVariant = 'ghost' | 'subtle';
 type IconButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -227,16 +264,45 @@ type InputBaseProps = {
     className?: string;
     tone?: 'default' | 'warning';
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    invalid?: boolean;
 };
-type TextInputProps = InputBaseProps & Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> & {
-    as?: 'input';
+type InputProps = InputBaseProps & Omit<InputHTMLAttributes<HTMLInputElement>, 'size'>;
+declare function Input({ className, tone, size, invalid, ...rest }: InputProps): react_jsx_runtime.JSX.Element;
+
+type NavRailPart = 'section' | 'item' | 'icon' | 'spacer';
+interface NavRailProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'> {
+    activeKey?: string;
+    onChange?: (key: string) => void;
+    children: ReactNode;
+    classNames?: Partial<Record<NavRailPart, string>>;
+    orientation?: 'vertical' | 'horizontal';
+}
+declare function NavRailRoot({ activeKey, onChange, classNames, orientation, className, children, ...props }: NavRailProps): react_jsx_runtime.JSX.Element;
+type CommonItemProps = {
+    value: string;
+    icon: ReactNode;
+    label: string;
+    disabled?: boolean;
+    className?: string;
 };
-type TextareaProps$1 = InputBaseProps & Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'size'> & {
-    as: 'textarea';
+interface NavRailSectionProps extends HTMLAttributes<HTMLDivElement> {
+    label?: string;
+    children: ReactNode;
+}
+interface NavRailButtonItemProps extends CommonItemProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'value'> {
+    href?: never;
+}
+interface NavRailLinkItemProps extends CommonItemProps, Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'children' | 'href'> {
+    href: string;
+}
+declare function NavRailItem(props: NavRailButtonItemProps | NavRailLinkItemProps): react_jsx_runtime.JSX.Element;
+declare function NavRailSpacer(): react_jsx_runtime.JSX.Element;
+declare function NavRailSection({ label, className, children, ...props }: NavRailSectionProps): react_jsx_runtime.JSX.Element;
+declare const NavRail: typeof NavRailRoot & {
+    Item: typeof NavRailItem;
+    Section: typeof NavRailSection;
+    Spacer: typeof NavRailSpacer;
 };
-type InputProps = TextInputProps | TextareaProps$1;
-declare function Input(props: TextInputProps): React.JSX.Element;
-declare function Input(props: TextareaProps$1): React.JSX.Element;
 
 type PanelVariant = 'default' | 'subtle' | 'raised';
 type PanelPadding = 'none' | 'sm' | 'md' | 'lg';
@@ -254,53 +320,151 @@ declare function PanelHeader({ className, children, ...props }: PanelSectionProp
 declare function PanelBody({ className, children, ...props }: PanelSectionProps): react_jsx_runtime.JSX.Element;
 declare function PanelFooter({ className, children, ...props }: PanelSectionProps): react_jsx_runtime.JSX.Element;
 
-interface SegmentedOption<T extends string> {
-    value: T;
-    label: string;
+type PopoverTriggerMode = 'click' | 'hover';
+type PopoverPlacement = 'top' | 'bottom' | 'left' | 'right' | 'auto';
+type PopoverSide = 'top' | 'bottom' | 'left' | 'right';
+type PopoverAlign = 'start' | 'center' | 'end';
+type PopoverPart = 'trigger' | 'content' | 'arrow';
+interface PopoverProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: PopoverTriggerMode;
+    classNames?: Partial<Record<PopoverPart, string>>;
+    children: ReactNode;
+}
+declare function PopoverRoot({ open, defaultOpen, onOpenChange, trigger, classNames, children, }: PopoverProps): react_jsx_runtime.JSX.Element;
+interface PopoverTriggerProps {
+    asChild?: boolean;
     disabled?: boolean;
+    className?: string;
+    children: ReactElement;
 }
-interface SegmentedControlProps<T extends string> {
+declare function PopoverTrigger({ asChild, disabled, className, children, }: PopoverTriggerProps): react_jsx_runtime.JSX.Element;
+interface PopoverContentProps extends HTMLAttributes<HTMLDivElement> {
+    placement?: PopoverPlacement;
+    side?: PopoverSide;
+    align?: PopoverAlign;
+    sideOffset?: number;
+    alignOffset?: number;
+    collisionPadding?: number;
+    portal?: boolean;
+    arrow?: boolean;
+    matchTriggerWidth?: boolean;
+    closeOnInteractOutside?: boolean;
+    closeOnEscape?: boolean;
+    closeOnPointerDownOutside?: boolean;
+    restoreFocus?: boolean;
+    initialFocusRef?: RefObject<HTMLElement | null>;
+    onInteractOutside?: (target: Node) => void;
+    onEscapeKeyDown?: () => void;
+    onPointerDownOutside?: (target: Node) => void;
+    classNames?: Partial<Record<PopoverPart, string>>;
+}
+declare function PopoverContent({ placement, side, align, sideOffset, alignOffset, collisionPadding, portal, arrow, matchTriggerWidth, closeOnInteractOutside, closeOnEscape, closeOnPointerDownOutside, restoreFocus, initialFocusRef, onInteractOutside, onEscapeKeyDown, onPointerDownOutside, className, classNames, children, onMouseEnter, onMouseLeave, onFocus, onBlur, ...props }: PopoverContentProps): react_jsx_runtime.JSX.Element | null;
+declare const Popover: typeof PopoverRoot & {
+    Root: typeof PopoverRoot;
+    Trigger: typeof PopoverTrigger;
+    Content: typeof PopoverContent;
+};
+
+/**
+ * Shared option model for single-select controls (Select, SegmentedControl,
+ * and future RadioGroup). Using a common type prevents divergent option
+ * structures across the form family.
+ */
+type ChoiceOption<T extends string> = {
     value: T;
-    onChange: (value: T) => void;
-    options: Array<SegmentedOption<T>>;
-    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    label: ReactNode;
+    disabled?: boolean;
+    /** Explicit string representation for accessibility and search/filter use
+     *  cases where `label` is a ReactNode that cannot be inferred as text. */
+    textValue?: string;
+};
+
+type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'onChange'> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    size?: RadioSize;
+    invalid?: boolean;
+    ariaLabel?: string;
+    children?: ReactNode;
+}
+declare function Radio({ checked: checkedProp, defaultChecked, onCheckedChange, size, invalid, disabled, required, id, name, value, className, ariaLabel, children, onKeyDown, 'aria-describedby': ariaDescribedBy, ...rest }: RadioProps): react_jsx_runtime.JSX.Element;
+interface RadioGroupProps<T extends string> {
+    value?: T;
+    defaultValue?: T;
+    onValueChange?: (value: T) => void;
+    options?: Array<ChoiceOption<T>>;
+    size?: RadioSize;
+    orientation?: 'vertical' | 'horizontal';
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    id?: string;
+    name?: string;
     className?: string;
-    ariaLabel: string;
+    ariaLabel?: string;
+    children?: ReactNode;
+    'aria-describedby'?: string;
 }
-declare function SegmentedControl<T extends string>({ value, onChange, options, size, className, ariaLabel, }: SegmentedControlProps<T>): react_jsx_runtime.JSX.Element;
+declare function RadioGroup<T extends string>({ value: valueProp, defaultValue, onValueChange, options, size, orientation, disabled: disabledProp, required, invalid, id, name, className, ariaLabel, children, 'aria-describedby': ariaDescribedBy, }: RadioGroupProps<T>): react_jsx_runtime.JSX.Element;
 
-interface SelectOption<T extends string> {
-    value: T;
-    label: string;
+interface SegmentedControlProps<T extends string> {
+    value?: T;
+    defaultValue?: T;
+    onValueChange?: (value: T) => void;
+    options: Array<ChoiceOption<T>>;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
     disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    id?: string;
+    name?: string;
+    className?: string;
+    ariaLabel?: string;
+    'aria-describedby'?: string;
 }
+declare function SegmentedControl<T extends string>({ value: valueProp, defaultValue, onValueChange, options, size, disabled: disabledProp, required, invalid, id, name, className, ariaLabel, 'aria-describedby': ariaDescribedBy, }: SegmentedControlProps<T>): react_jsx_runtime.JSX.Element;
+
 interface SelectRenderValueArgs<T extends string> {
     open: boolean;
     placeholder: string;
-    selectedOption?: SelectOption<T>;
+    selectedOption?: ChoiceOption<T>;
 }
 interface SelectRenderOptionArgs<T extends string> {
-    option: SelectOption<T>;
+    option: ChoiceOption<T>;
     index: number;
     selected: boolean;
     highlighted: boolean;
 }
 type SelectPart = 'trigger' | 'chevron' | 'dropdown' | 'option';
 interface SelectProps<T extends string> {
-    value: T | '';
-    onChange: (value: T) => void;
-    options: Array<SelectOption<T>>;
+    value?: T | null;
+    defaultValue?: T | null;
+    onValueChange?: (value: T | undefined) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    options: Array<ChoiceOption<T>>;
     placeholder?: string;
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
     tone?: 'default' | 'warning';
     disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    id?: string;
+    name?: string;
     className?: string;
-    ariaLabel: string;
+    ariaLabel?: string;
+    'aria-describedby'?: string;
     renderValue?: (args: SelectRenderValueArgs<T>) => ReactNode;
     renderOption?: (args: SelectRenderOptionArgs<T>) => ReactNode;
     classNames?: Partial<Record<SelectPart, string>>;
 }
-declare function Select<T extends string>({ value, onChange, options, placeholder, size, tone, disabled, className, ariaLabel, renderValue, renderOption, classNames, }: SelectProps<T>): react_jsx_runtime.JSX.Element;
+declare function Select<T extends string>({ value: valueProp, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, options, placeholder, size, tone, disabled: disabledProp, required, invalid, id, name, className, ariaLabel, 'aria-describedby': ariaDescribedBy, renderValue, renderOption, classNames, }: SelectProps<T>): react_jsx_runtime.JSX.Element;
 
 type SkeletonAnimation = 'pulse' | 'scan';
 type SkeletonTone = 'default' | 'emphasis' | 'warm';
@@ -339,22 +503,151 @@ declare function StatusNotice({ tone, layout, icon, title, description, action,
 
 type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 interface SwitchProps {
-    checked: boolean;
-    onChange: (checked: boolean) => void;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
     size?: SwitchSize;
     disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    id?: string;
+    name?: string;
     className?: string;
-    ariaLabel: string;
+    ariaLabel?: string;
+    'aria-describedby'?: string;
+}
+declare function Switch({ checked: checkedProp, defaultChecked, onCheckedChange, size, disabled, required, invalid, id, name, className, ariaLabel, 'aria-describedby': ariaDescribedBy, }: SwitchProps): react_jsx_runtime.JSX.Element;
+
+type TableSortDirection = 'asc' | 'desc';
+type TableSortCycle = 'binary' | 'ternary';
+type TablePart = 'headerCell' | 'headerSortButton' | 'headerLabel' | 'resizeHandle' | 'cell' | 'selectionCell' | 'selectionControl' | 'loadingState' | 'emptyState' | 'skeletonCell';
+interface TableSortState {
+    key: string;
+    direction: TableSortDirection;
+}
+interface TableColumnDef<Row extends Record<string, unknown>> {
+    key: string;
+    header: ReactNode;
+    accessor?: keyof Row | ((row: Row, index: number) => ReactNode);
+    cell?: (row: Row, index: number) => ReactNode;
+    sortable?: boolean;
+    compare?: (a: Row, b: Row, leftIndex: number, rightIndex: number) => number;
+    align?: 'start' | 'center' | 'end';
+    width?: string | number;
+    minWidth?: number;
+    resizable?: boolean;
+    headerClassName?: string;
+    cellClassName?: string;
+    renderHeader?: (args: {
+        column: TableColumnDef<Row>;
+        sorted?: TableSortDirection;
+        sortable: boolean;
+    }) => ReactNode;
+    renderCell?: (args: {
+        column: TableColumnDef<Row>;
+        row: Row;
+        rowId: string;
+        index: number;
+        selected: boolean;
+        value: ReactNode;
+    }) => ReactNode;
+}
+interface VirtualizeOptions {
+    overscan?: number;
+    height?: number;
+}
+interface TableProps<Row extends Record<string, unknown>> {
+    columns: Array<TableColumnDef<Row>>;
+    data: Row[];
+    visibleColumnKeys?: Set<string>;
+    defaultVisibleColumnKeys?: Set<string>;
+    columnWidths?: Partial<Record<string, number>>;
+    defaultColumnWidths?: Partial<Record<string, number>>;
+    onColumnWidthsChange?: (widths: Partial<Record<string, number>>) => void;
+    getRowId?: (row: Row, index: number) => string;
+    selectionMode?: 'single' | 'multiple';
+    selectedRows?: Set<string>;
+    defaultSelectedRows?: Set<string>;
+    onSelectionChange?: (selected: Set<string>) => void;
+    sort?: TableSortState | null;
+    defaultSort?: TableSortState | null;
+    onSort?: (key: string, direction: TableSortDirection | null) => void;
+    onSortChange?: (sort: TableSortState | null) => void;
+    sortCycle?: TableSortCycle;
+    getSortButtonAriaLabel?: (args: {
+        column: TableColumnDef<Row>;
+        sorted?: TableSortDirection;
+        nextDirection: TableSortDirection | null;
+    }) => string;
+    selectionColumnAriaLabel?: string;
+    getRowSelectionAriaLabel?: (args: {
+        row: Row;
+        rowId: string;
+        index: number;
+        selected: boolean;
+        selectionMode: 'single' | 'multiple';
+    }) => string;
+    getSelectAllAriaLabel?: (args: {
+        allSelected: boolean;
+        partiallySelected: boolean;
+        selectableCount: number;
+    }) => string;
+    isRowSelectable?: (row: Row, index: number) => boolean;
+    rowHeight?: 'compact' | 'default';
+    stickyHeader?: boolean;
+    virtualized?: boolean | VirtualizeOptions;
+    loading?: boolean;
+    loadingState?: ReactNode;
+    skeletonRows?: number;
+    emptyState?: ReactNode;
+    className?: string;
+    classNames?: Partial<Record<TablePart, string>>;
+}
+declare function Table<Row extends Record<string, unknown>>({ columns, data, visibleColumnKeys, defaultVisibleColumnKeys, columnWidths, defaultColumnWidths, onColumnWidthsChange, getRowId, selectionMode, selectedRows, defaultSelectedRows, onSelectionChange, sort, defaultSort, onSort, onSortChange, sortCycle, getSortButtonAriaLabel, selectionColumnAriaLabel, getRowSelectionAriaLabel, getSelectAllAriaLabel, isRowSelectable, rowHeight, stickyHeader, virtualized, loading, loadingState, skeletonRows, emptyState, className, classNames, }: TableProps<Row>): react_jsx_runtime.JSX.Element;
+
+type TreePart = 'item' | 'button' | 'label' | 'chevron';
+interface TreeNode<T = unknown> {
+    key: string;
+    label: ReactNode;
+    textValue?: string;
+    children?: TreeNode<T>[];
+    data?: T;
+    disabled?: boolean;
+}
+interface TreeRenderArgs<T = unknown> {
+    node: TreeNode<T>;
+    depth: number;
+    expanded: boolean;
+    selected: boolean;
+    match: boolean;
+}
+interface TreeProps<T = unknown> {
+    nodes: TreeNode<T>[];
+    expandedKeys?: Set<string>;
+    defaultExpandedKeys?: Set<string>;
+    onExpand?: (key: string, expanded: boolean) => void;
+    onExpandedKeysChange?: (keys: Set<string>) => void;
+    selectedKey?: string;
+    defaultSelectedKey?: string;
+    onSelect?: (key: string) => void;
+    renderNode?: (args: TreeRenderArgs<T>) => ReactNode;
+    searchQuery?: string;
+    className?: string;
+    ariaLabel?: string;
+    classNames?: Partial<Record<TreePart, string>>;
 }
-declare function Switch({ checked, onChange, size, disabled, className, ariaLabel, }: SwitchProps): react_jsx_runtime.JSX.Element;
+declare function Tree<T = unknown>({ nodes, expandedKeys, defaultExpandedKeys, onExpand, onExpandedKeysChange, selectedKey, defaultSelectedKey, onSelect, renderNode, searchQuery, className, ariaLabel, classNames, }: TreeProps<T>): react_jsx_runtime.JSX.Element;
 
+type TabsPart = 'list' | 'trigger' | 'content';
 interface TabsRootProps extends HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
     value?: string;
     defaultValue?: string;
     onValueChange?: (value: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+    classNames?: Partial<Record<TabsPart, string>>;
 }
-declare function TabsRoot({ children, value, defaultValue, onValueChange, className, ...props }: TabsRootProps): react_jsx_runtime.JSX.Element;
+declare function TabsRoot({ children, value, defaultValue, onValueChange, orientation, classNames, className, ...props }: TabsRootProps): react_jsx_runtime.JSX.Element;
 interface TabsListProps extends HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
     ariaLabel?: string;
@@ -383,8 +676,9 @@ interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
     resize?: 'none' | 'vertical' | 'both';
     autoResize?: boolean;
+    invalid?: boolean;
 }
-declare function Textarea({ className, tone, size, resize, autoResize, style, onInput, rows, ...props }: TextareaProps): react_jsx_runtime.JSX.Element;
+declare function Textarea({ className, tone, size, resize, autoResize, invalid, style, onInput, rows, ...props }: TextareaProps): react_jsx_runtime.JSX.Element;
 
 type ToastTone = 'success' | 'warning' | 'danger' | 'info';
 type ToastPart = 'container' | 'toast' | 'icon' | 'content' | 'title' | 'message' | 'close';
@@ -437,4 +731,4 @@ interface TooltipProps {
 }
 declare function Tooltip({ content, placement: preferredPlacement, density, showDelay, hideDelay, arrow, renderArrow, className, children, classNames, }: TooltipProps): react_jsx_runtime.JSX.Element;
 
-export { Avatar, Badge, type BadgeProps, Button, type ButtonProps, Collapsible, CollapsibleContent, type CollapsibleContentProps, type CollapsiblePart, CollapsibleRoot, type CollapsibleRootProps, CollapsibleTrigger, type CollapsibleTriggerProps, ConfirmProvider, Dialog, Drawer, DropdownMenu, type DropdownMenuAlign, type DropdownMenuContentProps, type DropdownMenuItemProps, type DropdownMenuProps, type DropdownMenuRole, type DropdownMenuSide, type DropdownMenuTriggerProps, Field, type FieldProps, IconButton, type IconButtonProps, Input, type InputProps, Panel, PanelBody, PanelFooter, PanelHeader, SegmentedControl, type SegmentedOption, Select, type SelectOption, type SelectRenderOptionArgs, type SelectRenderValueArgs, Skeleton, type SkeletonAnimation, type SkeletonSpeed, type SkeletonTone, Spinner, StatusNotice, type StatusNoticePart, type StatusNoticeProps, Switch, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, TabsRoot, type TabsRootProps, TabsTrigger, type TabsTriggerProps, Textarea, type TextareaProps, type ToastInput, ToastProvider, type ToastRenderArgs, Tooltip, buttonClassName, useConfirm, useToast };
+export { Avatar, Badge, type BadgeProps, Button, type ButtonProps, Checkbox, type CheckboxProps, type ChoiceOption, Collapsible, CollapsibleContent, type CollapsibleContentProps, type CollapsiblePart, CollapsibleRoot, type CollapsibleRootProps, CollapsibleTrigger, type CollapsibleTriggerProps, ConfirmProvider, Dialog, Drawer, DropdownMenu, type DropdownMenuAlign, type DropdownMenuContentProps, type DropdownMenuItemProps, type DropdownMenuProps, type DropdownMenuRole, type DropdownMenuSide, type DropdownMenuTriggerProps, Field, type FieldContextValue, type FieldPart, type FieldProps, IconButton, type IconButtonProps, Input, type InputProps, NavRail, type NavRailButtonItemProps, NavRailItem, type NavRailLinkItemProps, type NavRailPart, type NavRailProps, NavRailRoot, type NavRailSectionProps, NavRailSpacer, Panel, PanelBody, PanelFooter, PanelHeader, Popover, type PopoverAlign, PopoverContent, type PopoverContentProps, type PopoverPart, type PopoverPlacement, type PopoverProps, PopoverRoot, type PopoverSide, PopoverTrigger, type PopoverTriggerMode, type PopoverTriggerProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, SegmentedControl, type SegmentedControlProps, Select, type SelectPart, type SelectProps, type SelectRenderOptionArgs, type SelectRenderValueArgs, Skeleton, type SkeletonAnimation, type SkeletonSpeed, type SkeletonTone, Spinner, StatusNotice, type StatusNoticePart, type StatusNoticeProps, Switch, type SwitchProps, Table, type TableColumnDef, type TablePart, type TableProps, type TableSortCycle, type TableSortDirection, type TableSortState, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsPart, TabsRoot, type TabsRootProps, TabsTrigger, type TabsTriggerProps, Textarea, type TextareaProps, type ToastInput, ToastProvider, type ToastRenderArgs, Tooltip, Tree, type TreeNode, type TreePart, type TreeProps, type TreeRenderArgs, type VirtualizeOptions, buttonClassName, useConfirm, useToast };