@onesaz/ui 0.3.1 → 0.3.3

package/dist/index.d.ts

@@ -5,6 +5,9 @@ import { ClassValue } from 'clsx';
 import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
 
 interface ThemeProviderProps {
     children: React.ReactNode;
@@ -188,6 +191,15 @@ interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
     size?: 'default' | 'sm' | 'lg' | 'icon';
 }
 declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+interface IconButtonProps extends Omit<ButtonProps, 'size'> {
+    /** Size of the icon button */
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    /** Whether the button is rounded (circular) */
+    rounded?: boolean;
+    /** Aria label for accessibility (required for icon-only buttons) */
+    'aria-label': string;
+}
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
 
 interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
     /** Input size variant */
@@ -201,6 +213,37 @@ interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
 }
 declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
 
+interface InputAdornmentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Position of the adornment */
+    position?: 'start' | 'end';
+    /** Disable pointer events (useful for icons) */
+    disablePointerEvents?: boolean;
+}
+/**
+ * InputAdornment - A wrapper component for input adornments (icons, text, etc.)
+ *
+ * Can be used standalone or with Input/TextField components.
+ *
+ * @example
+ * ```tsx
+ * <Input
+ *   startAdornment={
+ *     <InputAdornment position="start">
+ *       <SearchIcon className="h-4 w-4" />
+ *     </InputAdornment>
+ *   }
+ * />
+ *
+ * // Or with text
+ * <Input
+ *   startAdornment={
+ *     <InputAdornment position="start">$</InputAdornment>
+ *   }
+ * />
+ * ```
+ */
+declare const InputAdornment: React.ForwardRefExoticComponent<InputAdornmentProps & React.RefAttributes<HTMLDivElement>>;
+
 interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
 }
 declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
@@ -218,6 +261,10 @@ interface TextFieldProps extends Omit<InputProps, 'inputSize' | 'size'> {
     size?: 'sm' | 'md' | 'lg';
     /** Full width mode */
     fullWidth?: boolean;
+    /** Start adornment (icon, text, etc.) */
+    startAdornment?: React.ReactNode;
+    /** End adornment (icon, text, etc.) */
+    endAdornment?: React.ReactNode;
 }
 declare const TextField: React.ForwardRefExoticComponent<TextFieldProps & React.RefAttributes<HTMLInputElement>>;
 
@@ -380,11 +427,123 @@ declare const DialogNamespace: React.FC<DialogPrimitive.DialogProps> & {
     Description: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
 };
 
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface AlertDialogContentProps extends React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Content> {
+    /** Visual variant of the alert dialog */
+    variant?: 'default' | 'destructive' | 'success' | 'warning' | 'info';
+    /** Whether to show an icon */
+    showIcon?: boolean;
+}
+declare const AlertDialogContent: React.ForwardRefExoticComponent<AlertDialogContentProps & React.RefAttributes<HTMLDivElement>>;
+interface AlertDialogHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const AlertDialogHeader: React.ForwardRefExoticComponent<AlertDialogHeaderProps & React.RefAttributes<HTMLDivElement>>;
+interface AlertDialogFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const AlertDialogFooter: React.ForwardRefExoticComponent<AlertDialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
 interface SpinnerProps extends React.HTMLAttributes<HTMLDivElement> {
     size?: 'sm' | 'default' | 'lg';
 }
 declare const Spinner: React.ForwardRefExoticComponent<SpinnerProps & React.RefAttributes<HTMLDivElement>>;
 
+interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The variant/severity of the alert */
+    variant?: 'default' | 'info' | 'success' | 'warning' | 'error' | 'destructive';
+    /** Whether the alert is dismissible */
+    dismissible?: boolean;
+    /** Callback when dismissed */
+    onDismiss?: () => void;
+    /** Icon to show (if undefined, a default icon is used based on variant) */
+    icon?: React.ReactNode;
+    /** Whether to show the default icon */
+    showIcon?: boolean;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+interface AlertTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+}
+declare const AlertTitle: React.ForwardRefExoticComponent<AlertTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+interface AlertDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+}
+declare const AlertDescription: React.ForwardRefExoticComponent<AlertDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const TooltipRoot: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipPortal: React.FC<TooltipPrimitive.TooltipPortalProps>;
+declare const TooltipArrow: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>, "ref"> & React.RefAttributes<SVGSVGElement>>;
+interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
+    /** Whether to show an arrow pointing to the trigger */
+    showArrow?: boolean;
+}
+declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+interface TooltipProps {
+    /** The content to show in the tooltip */
+    content: React.ReactNode;
+    /** The element that triggers the tooltip */
+    children: React.ReactNode;
+    /** Side where the tooltip appears */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Alignment of the tooltip */
+    align?: 'start' | 'center' | 'end';
+    /** Delay before showing (ms) */
+    delayDuration?: number;
+    /** Whether the tooltip is open (controlled) */
+    open?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Whether the tooltip should be disabled */
+    disabled?: boolean;
+    /** Whether to show an arrow */
+    showArrow?: boolean;
+    /** Additional className for the content */
+    className?: string;
+}
+declare const Tooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface LinearProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Progress value (0-100). If undefined, shows indeterminate state */
+    value?: number;
+    /** Color variant */
+    variant?: 'default' | 'success' | 'warning' | 'error' | 'info';
+    /** Size of the progress bar */
+    size?: 'sm' | 'md' | 'lg';
+    /** Whether to show the value label */
+    showValue?: boolean;
+    /** Custom label format */
+    formatValue?: (value: number) => string;
+    /** Whether to animate (only for determinate progress) */
+    animated?: boolean;
+}
+declare const LinearProgress: React.ForwardRefExoticComponent<LinearProgressProps & React.RefAttributes<HTMLDivElement>>;
+interface CircularProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Progress value (0-100). If undefined, shows indeterminate state */
+    value?: number;
+    /** Color variant */
+    variant?: 'default' | 'success' | 'warning' | 'error' | 'info';
+    /** Size of the circular progress */
+    size?: 'sm' | 'md' | 'lg' | 'xl' | number;
+    /** Thickness of the progress ring */
+    thickness?: number;
+    /** Whether to show the value in the center */
+    showValue?: boolean;
+    /** Custom label format */
+    formatValue?: (value: number) => string;
+    /** Content to show in the center */
+    children?: React.ReactNode;
+}
+declare const CircularProgress: React.ForwardRefExoticComponent<CircularProgressProps & React.RefAttributes<HTMLDivElement>>;
+interface ProgressProps extends LinearProgressProps {
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+
 declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
 declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
 declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
@@ -402,6 +561,81 @@ declare const TableNamespace: React.ForwardRefExoticComponent<React.HTMLAttribut
     Caption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
 };
 
+interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Image source URL */
+    src?: string;
+    /** Alt text for the image */
+    alt?: string;
+    /** Size of the avatar */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    /** Fallback text (usually initials) when no image */
+    fallback?: string;
+    /** Shape of the avatar */
+    shape?: 'circle' | 'square';
+    /** Whether to show a border */
+    bordered?: boolean;
+    /** Custom fallback element */
+    fallbackElement?: React.ReactNode;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface AvatarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Maximum number of avatars to show */
+    max?: number;
+    /** Size for all avatars in the group */
+    size?: AvatarProps['size'];
+    /** Children should be Avatar components */
+    children: React.ReactNode;
+}
+declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Variant of the skeleton shape */
+    variant?: 'text' | 'circular' | 'rectangular' | 'rounded';
+    /** Width of the skeleton (can be number for px or string for any CSS value) */
+    width?: number | string;
+    /** Height of the skeleton (can be number for px or string for any CSS value) */
+    height?: number | string;
+    /** Whether to animate the skeleton */
+    animation?: 'pulse' | 'wave' | 'none';
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+interface SkeletonTextProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Number of lines */
+    lines?: number;
+    /** Width of the last line (percentage or 'full') */
+    lastLineWidth?: number | 'full';
+    /** Gap between lines */
+    gap?: 'sm' | 'md' | 'lg';
+    /** Animation type */
+    animation?: SkeletonProps['animation'];
+}
+declare const SkeletonText: React.ForwardRefExoticComponent<SkeletonTextProps & React.RefAttributes<HTMLDivElement>>;
+interface SkeletonAvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Size of the avatar skeleton */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Animation type */
+    animation?: SkeletonProps['animation'];
+}
+declare const SkeletonAvatar: React.ForwardRefExoticComponent<SkeletonAvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface SkeletonCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Whether to show an image placeholder */
+    hasImage?: boolean;
+    /** Image height */
+    imageHeight?: number;
+    /** Number of text lines */
+    lines?: number;
+    /** Animation type */
+    animation?: SkeletonProps['animation'];
+}
+declare const SkeletonCard: React.ForwardRefExoticComponent<SkeletonCardProps & React.RefAttributes<HTMLDivElement>>;
+interface SkeletonTableRowProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Number of columns */
+    columns?: number;
+    /** Animation type */
+    animation?: SkeletonProps['animation'];
+}
+declare const SkeletonTableRow: React.ForwardRefExoticComponent<SkeletonTableRowProps & React.RefAttributes<HTMLDivElement>>;
+
 interface PaginationProps extends React.HTMLAttributes<HTMLElement> {
 }
 declare const PaginationContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLUListElement> & React.RefAttributes<HTMLUListElement>>;
@@ -427,7 +661,7 @@ interface ComboboxOption {
     label: string;
     disabled?: boolean;
 }
-interface ComboboxProps {
+interface ComboboxSingleProps {
     options: ComboboxOption[];
     value?: string;
     defaultValue?: string;
@@ -437,9 +671,482 @@ interface ComboboxProps {
     emptyMessage?: string;
     disabled?: boolean;
     className?: string;
+    multiple?: false;
 }
+interface ComboboxMultipleProps {
+    options: ComboboxOption[];
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    className?: string;
+    multiple: true;
+    /** Maximum number of items to display as chips before showing "+N more" */
+    maxDisplayItems?: number;
+}
+type ComboboxProps = ComboboxSingleProps | ComboboxMultipleProps;
 declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLInputElement>>;
 
+interface GridColDef<TData = any> {
+    field: string;
+    headerName?: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    sortable?: boolean;
+    filterable?: boolean;
+    editable?: boolean;
+    hide?: boolean;
+    hideable?: boolean;
+    align?: 'left' | 'center' | 'right';
+    headerAlign?: 'left' | 'center' | 'right';
+    renderCell?: (params: GridRenderCellParams<TData>) => React.ReactNode;
+    renderHeader?: (params: GridRenderHeaderParams) => React.ReactNode;
+    valueGetter?: (params: GridValueGetterParams<TData>) => any;
+    valueFormatter?: (params: GridValueFormatterParams) => string;
+    type?: 'string' | 'number' | 'date' | 'dateTime' | 'boolean';
+    wrapText?: boolean;
+    cellClassName?: string;
+    export?: boolean;
+    hideExport?: boolean;
+    disableExport?: boolean;
+}
+interface GridRenderCellParams<TData = any> {
+    row: TData;
+    value: any;
+    field: string;
+    rowIndex: number;
+}
+interface GridRenderHeaderParams {
+    field: string;
+    colDef: GridColDef;
+}
+interface GridValueGetterParams<TData = any> {
+    row: TData;
+    field: string;
+}
+interface GridValueFormatterParams {
+    value: any;
+}
+interface PaginationModel {
+    page: number;
+    pageSize: number;
+}
+interface GridRowSelectionModel {
+    [key: string]: boolean;
+}
+interface ColumnVisibilityModel {
+    [key: string]: boolean;
+}
+type GridDensity = 'compact' | 'standard' | 'comfortable';
+interface DataGridProps<TData = any> {
+    rows: TData[];
+    columns: GridColDef<TData>[];
+    getRowId?: (row: TData) => string | number;
+    loading?: boolean;
+    title?: string;
+    toolBar?: boolean;
+    checkboxSelection?: boolean;
+    rowSelectionModel?: GridRowSelectionModel;
+    onRowSelectionModelChange?: (model: GridRowSelectionModel) => void;
+    disableRowSelectionOnClick?: boolean;
+    columnVisibilityModel?: ColumnVisibilityModel;
+    onColumnVisibilityModelChange?: (model: ColumnVisibilityModel) => void;
+    paginationMode?: 'client' | 'server';
+    paginationModel?: PaginationModel;
+    onPaginationModelChange?: (model: PaginationModel) => void;
+    rowCount?: number;
+    pageSizeOptions?: number[];
+    sortingMode?: 'client' | 'server';
+    filterMode?: 'client' | 'server';
+    height?: number | string;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+    density?: GridDensity;
+    showCellVerticalBorder?: boolean;
+    showColumnVerticalBorder?: boolean;
+    hideFooter?: boolean;
+    hideFooterPagination?: boolean;
+    virtualized?: boolean;
+    overscan?: number;
+    wrapText?: boolean;
+    getRowClassName?: (params: {
+        row: TData;
+        rowIndex: number;
+    }) => string;
+    slotProps?: {
+        toolbar?: {
+            getExportedColumns?: (columns: GridColDef[]) => GridColDef[];
+            showQuickFilter?: boolean;
+            showColumnSelector?: boolean;
+            showExport?: boolean;
+            customButtons?: React.ReactNode;
+            moreOptions?: {
+                label: string;
+                onClick: () => void;
+                icon?: React.ReactNode;
+            }[];
+        };
+    };
+    onExport?: (data: TData[], columns: GridColDef<TData>[]) => void;
+    exportFileName?: string;
+    resizableColumns?: boolean;
+    onColumnResize?: (columnId: string, width: number) => void;
+    className?: string;
+    sx?: React.CSSProperties;
+    actions?: {
+        edit?: boolean;
+        del?: boolean;
+    };
+    sensitiveInfo?: boolean;
+    autoHeight?: boolean;
+    disableColumnMenu?: boolean;
+    disableColumnFilter?: boolean;
+    disableColumnSelector?: boolean;
+    disableDensitySelector?: boolean;
+}
+declare function DataGrid<TData extends Record<string, any>>({ rows, columns, getRowId, loading, title, toolBar, checkboxSelection, rowSelectionModel, onRowSelectionModelChange, disableRowSelectionOnClick, columnVisibilityModel, onColumnVisibilityModelChange, paginationMode, paginationModel, onPaginationModelChange, rowCount, pageSizeOptions, sortingMode, filterMode, height, minHeight, maxHeight, density, showCellVerticalBorder, showColumnVerticalBorder, hideFooter, hideFooterPagination, virtualized, overscan, wrapText, getRowClassName, slotProps, className, sx, autoHeight, disableColumnSelector, onExport, exportFileName, resizableColumns, onColumnResize, }: DataGridProps<TData>): react_jsx_runtime.JSX.Element;
+declare namespace DataGrid {
+    var displayName: string;
+}
+
+interface ListProps extends React.HTMLAttributes<HTMLUListElement> {
+    /** Whether the list has dividers between items */
+    dividers?: boolean;
+    /** Padding for each list item */
+    dense?: boolean;
+    /** Whether items are clickable (adds hover styles) */
+    clickable?: boolean;
+}
+declare const List: React.ForwardRefExoticComponent<ListProps & React.RefAttributes<HTMLUListElement>>;
+interface ListItemProps extends React.HTMLAttributes<HTMLLIElement> {
+    /** Whether this item is selected/active */
+    selected?: boolean;
+    /** Whether this item is disabled */
+    disabled?: boolean;
+    /** Whether this item is clickable */
+    clickable?: boolean;
+    /** Leading element (icon, avatar, etc.) */
+    leading?: React.ReactNode;
+    /** Trailing element (icon, action, etc.) */
+    trailing?: React.ReactNode;
+    /** Secondary action element */
+    secondaryAction?: React.ReactNode;
+}
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLLIElement>>;
+interface ListItemTextProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Primary text */
+    primary?: React.ReactNode;
+    /** Secondary text */
+    secondary?: React.ReactNode;
+    /** Whether to prevent text wrapping */
+    noWrap?: boolean;
+}
+declare const ListItemText: React.ForwardRefExoticComponent<ListItemTextProps & React.RefAttributes<HTMLDivElement>>;
+interface ListItemIconProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const ListItemIcon: React.ForwardRefExoticComponent<ListItemIconProps & React.RefAttributes<HTMLDivElement>>;
+interface ListItemAvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const ListItemAvatar: React.ForwardRefExoticComponent<ListItemAvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface ListSubheaderProps extends React.HTMLAttributes<HTMLLIElement> {
+    /** Whether the subheader is sticky */
+    sticky?: boolean;
+}
+declare const ListSubheader: React.ForwardRefExoticComponent<ListSubheaderProps & React.RefAttributes<HTMLLIElement>>;
+interface ListDividerProps extends React.HTMLAttributes<HTMLLIElement> {
+    /** Whether the divider is inset (indented) */
+    inset?: boolean;
+}
+declare const ListDivider: React.ForwardRefExoticComponent<ListDividerProps & React.RefAttributes<HTMLLIElement>>;
+
+interface BreadcrumbsProps extends React.HTMLAttributes<HTMLElement> {
+    /** Custom separator element */
+    separator?: React.ReactNode;
+    /** Maximum number of items to display before collapsing */
+    maxItems?: number;
+    /** Number of items to show at the beginning when collapsed */
+    itemsBeforeCollapse?: number;
+    /** Number of items to show at the end when collapsed */
+    itemsAfterCollapse?: number;
+}
+declare const Breadcrumbs: React.ForwardRefExoticComponent<BreadcrumbsProps & React.RefAttributes<HTMLElement>>;
+interface BreadcrumbItemProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Whether this is the current/active page */
+    current?: boolean;
+    /** Href for the breadcrumb link */
+    href?: string;
+    /** Click handler */
+    onClick?: React.MouseEventHandler<HTMLAnchorElement | HTMLSpanElement>;
+}
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<BreadcrumbItemProps & React.RefAttributes<HTMLSpanElement>>;
+interface BreadcrumbLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+}
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<BreadcrumbLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+interface BreadcrumbSeparatorProps extends React.HTMLAttributes<HTMLSpanElement> {
+}
+declare const BreadcrumbSeparator: React.ForwardRefExoticComponent<BreadcrumbSeparatorProps & React.RefAttributes<HTMLSpanElement>>;
+interface BreadcrumbEllipsisProps extends React.HTMLAttributes<HTMLSpanElement> {
+}
+declare const BreadcrumbEllipsis: React.ForwardRefExoticComponent<BreadcrumbEllipsisProps & React.RefAttributes<HTMLSpanElement>>;
+interface BreadcrumbPageProps extends React.HTMLAttributes<HTMLSpanElement> {
+}
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<BreadcrumbPageProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuSubTriggerProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> {
+    inset?: boolean;
+}
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> {
+    inset?: boolean;
+}
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuLabelProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> {
+    inset?: boolean;
+}
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Drawer: React.FC<DialogPrimitive.DialogProps>;
+declare const DrawerTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DrawerClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DrawerPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DrawerOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DrawerContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    /** Side from which the drawer slides in */
+    side?: 'left' | 'right' | 'top' | 'bottom';
+    /** Whether to show the close button */
+    showClose?: boolean;
+}
+declare const DrawerContent: React.ForwardRefExoticComponent<DrawerContentProps & React.RefAttributes<HTMLDivElement>>;
+interface DrawerHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const DrawerHeader: React.ForwardRefExoticComponent<DrawerHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const DrawerTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DrawerDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+interface DrawerBodyProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const DrawerBody: React.ForwardRefExoticComponent<DrawerBodyProps & React.RefAttributes<HTMLDivElement>>;
+interface DrawerFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const DrawerFooter: React.ForwardRefExoticComponent<DrawerFooterProps & React.RefAttributes<HTMLDivElement>>;
+declare const Sheet: React.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SheetContent: React.ForwardRefExoticComponent<DrawerContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: React.ForwardRefExoticComponent<DrawerHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const SheetBody: React.ForwardRefExoticComponent<DrawerBodyProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetFooter: React.ForwardRefExoticComponent<DrawerFooterProps & React.RefAttributes<HTMLDivElement>>;
+
+interface TopBarProps extends React.HTMLAttributes<HTMLElement> {
+    /** Whether the topbar has a bottom border */
+    bordered?: boolean;
+    /** Whether the topbar is sticky at the top */
+    sticky?: boolean;
+    /** Height variant */
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const TopBar: React.ForwardRefExoticComponent<TopBarProps & React.RefAttributes<HTMLElement>>;
+interface TopBarBrandProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Logo element or image */
+    logo?: React.ReactNode;
+    /** Brand name text */
+    name?: string;
+    /** Link href for the brand */
+    href?: string;
+}
+declare const TopBarBrand: React.ForwardRefExoticComponent<TopBarBrandProps & React.RefAttributes<HTMLDivElement>>;
+interface TopBarNavProps extends React.HTMLAttributes<HTMLElement> {
+}
+declare const TopBarNav: React.ForwardRefExoticComponent<TopBarNavProps & React.RefAttributes<HTMLElement>>;
+interface TopBarNavItemProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Whether this nav item is active */
+    active?: boolean;
+}
+declare const TopBarNavItem: React.ForwardRefExoticComponent<TopBarNavItemProps & React.RefAttributes<HTMLAnchorElement>>;
+interface TopBarSectionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Alignment of the section */
+    align?: 'left' | 'center' | 'right';
+}
+declare const TopBarSection: React.ForwardRefExoticComponent<TopBarSectionProps & React.RefAttributes<HTMLDivElement>>;
+interface TopBarDividerProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const TopBarDivider: React.ForwardRefExoticComponent<TopBarDividerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SidebarContextValue {
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+}
+declare const useSidebar: () => SidebarContextValue;
+interface SidebarProps extends React.HTMLAttributes<HTMLElement> {
+    /** Whether the sidebar is collapsed */
+    collapsed?: boolean;
+    /** Callback when collapsed state changes */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Default collapsed state (uncontrolled) */
+    defaultCollapsed?: boolean;
+    /** Width when expanded */
+    width?: number | string;
+    /** Width when collapsed */
+    collapsedWidth?: number | string;
+    /** Whether the sidebar has a right border */
+    bordered?: boolean;
+}
+declare const Sidebar: React.ForwardRefExoticComponent<SidebarProps & React.RefAttributes<HTMLElement>>;
+interface SidebarHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarHeader: React.ForwardRefExoticComponent<SidebarHeaderProps & React.RefAttributes<HTMLDivElement>>;
+interface SidebarContentProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarContent: React.ForwardRefExoticComponent<SidebarContentProps & React.RefAttributes<HTMLDivElement>>;
+interface SidebarFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarFooter: React.ForwardRefExoticComponent<SidebarFooterProps & React.RefAttributes<HTMLDivElement>>;
+interface SidebarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Group label */
+    label?: string;
+}
+declare const SidebarGroup: React.ForwardRefExoticComponent<SidebarGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface SidebarItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** Whether this item is active */
+    active?: boolean;
+    /** Whether this item is disabled */
+    disabled?: boolean;
+    /** Badge or count to show */
+    badge?: React.ReactNode;
+    /** Click handler */
+    onClick?: () => void;
+    /** Link href */
+    href?: string;
+}
+declare const SidebarItem: React.ForwardRefExoticComponent<SidebarItemProps & React.RefAttributes<HTMLDivElement>>;
+interface SidebarSubMenuProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** Label text */
+    label: string;
+    /** Whether the submenu is open by default */
+    defaultOpen?: boolean;
+}
+declare const SidebarSubMenu: React.ForwardRefExoticComponent<SidebarSubMenuProps & React.RefAttributes<HTMLDivElement>>;
+interface SidebarToggleProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const SidebarToggle: React.ForwardRefExoticComponent<SidebarToggleProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface SidebarRailContextValue {
+    activeRail: string | null;
+    setActiveRail: (rail: string | null) => void;
+    expanded: boolean;
+    setExpanded: (expanded: boolean) => void;
+    hoverExpand: boolean;
+    railExpanded: boolean;
+    setRailExpanded: (expanded: boolean) => void;
+    overlayRail: boolean;
+    expandableRail: boolean;
+}
+declare const useSidebarRail: () => SidebarRailContextValue;
+interface SidebarRailProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Default active rail */
+    defaultActiveRail?: string | null;
+    /** Controlled active rail */
+    activeRail?: string | null;
+    /** Callback when active rail changes */
+    onActiveRailChange?: (rail: string | null) => void;
+    /** Whether the panel expands on hover (vs click) */
+    hoverExpand?: boolean;
+    /** Width of the icon rail */
+    railWidth?: number;
+    /** Width of the expanded panel */
+    panelWidth?: number;
+    /** Whether the icon rail can expand to show labels */
+    expandableRail?: boolean;
+    /** Default rail expanded state (uncontrolled) */
+    defaultRailExpanded?: boolean;
+    /** Controlled rail expanded state */
+    railExpanded?: boolean;
+    /** Callback when rail expanded state changes */
+    onRailExpandedChange?: (expanded: boolean) => void;
+    /** Width of expanded rail (labels visible) */
+    railExpandedWidth?: number;
+    /** Overlay expanded rail on top of secondary panel instead of taking layout space */
+    overlayRail?: boolean;
+}
+declare const SidebarRail: React.ForwardRefExoticComponent<SidebarRailProps & React.RefAttributes<HTMLDivElement>>;
+interface IconRailProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const IconRail: React.ForwardRefExoticComponent<IconRailProps & React.RefAttributes<HTMLDivElement>>;
+interface IconRailHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const IconRailHeader: React.ForwardRefExoticComponent<IconRailHeaderProps & React.RefAttributes<HTMLDivElement>>;
+interface IconRailContentProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const IconRailContent: React.ForwardRefExoticComponent<IconRailContentProps & React.RefAttributes<HTMLDivElement>>;
+interface IconRailFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const IconRailFooter: React.ForwardRefExoticComponent<IconRailFooterProps & React.RefAttributes<HTMLDivElement>>;
+interface IconRailItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Unique identifier for this rail item */
+    railId?: string;
+    /** Icon to display */
+    icon: React.ReactNode;
+    /** Tooltip label */
+    label?: string;
+    /** Whether this is just a button (no panel) */
+    asButton?: boolean;
+    /** Toggle rail expansion when clicked */
+    toggleRail?: boolean;
+}
+declare const IconRailItem: React.ForwardRefExoticComponent<IconRailItemProps & React.RefAttributes<HTMLButtonElement>>;
+interface RailPanelProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Which rail this panel belongs to */
+    railId: string;
+    /** Panel title */
+    title?: string;
+}
+declare const RailPanel: React.ForwardRefExoticComponent<RailPanelProps & React.RefAttributes<HTMLDivElement>>;
+interface RailPanelGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Group label */
+    label?: string;
+}
+declare const RailPanelGroup: React.ForwardRefExoticComponent<RailPanelGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface RailPanelItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** Whether this item is active */
+    active?: boolean;
+    /** Whether this item is disabled */
+    disabled?: boolean;
+    /** Badge or count */
+    badge?: React.ReactNode;
+    /** Link href */
+    href?: string;
+}
+declare const RailPanelItem: React.ForwardRefExoticComponent<RailPanelItemProps & React.RefAttributes<HTMLDivElement>>;
+
 declare const Playground: () => react_jsx_runtime.JSX.Element;
 
-export { Badge, type BadgeProps, Box, type BoxProps, Button, type ButtonProps, Caption, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, type CheckboxProps, Combobox, type ComboboxOption, type ComboboxProps, DialogNamespace as Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, FormControl, type FormControlProps, FormGroup, type FormGroupProps, FormHelperText, type FormHelperTextProps, FormLabel, type FormLabelProps, Grid, type GridProps, H1, H2, H3, H4, H5, H6, HStack, Input, type InputProps, Label, type LabelProps, NativeSelect, NativeSelectOption, type NativeSelectOptionProps, type NativeSelectProps, PaginationNamespace as Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, type PaginationLinkProps, PaginationNext, PaginationPrevious, type PaginationProps, Playground, Radio, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, type RadioProps, SelectNamespace as Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, type SeparatorProps, Spinner, type SpinnerProps, Stack, type StackProps, Switch, type SwitchProps, TableNamespace as Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Text, TextField, type TextFieldProps, Textarea, type TextareaProps, ThemeContext, type ThemeContextValue, ThemeProvider, type ThemeProviderProps, Typography, type TypographyProps, VStack, cn, useFormControl, useTheme };
+export { Alert, AlertDescription, type AlertDescriptionProps, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, type AlertProps, AlertTitle, type AlertTitleProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, Badge, type BadgeProps, Box, type BoxProps, BreadcrumbEllipsis, type BreadcrumbEllipsisProps, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbPage, type BreadcrumbPageProps, BreadcrumbSeparator, type BreadcrumbSeparatorProps, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, Caption, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, type CheckboxProps, CircularProgress, type CircularProgressProps, type ColumnVisibilityModel, Combobox, type ComboboxMultipleProps, type ComboboxOption, type ComboboxProps, type ComboboxSingleProps, DataGrid, type DataGridProps, DataGrid as DataGridV0, DialogNamespace as Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Drawer, DrawerBody, type DrawerBodyProps, DrawerClose, DrawerContent, type DrawerContentProps, DrawerDescription, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, FormControl, type FormControlProps, FormGroup, type FormGroupProps, FormHelperText, type FormHelperTextProps, FormLabel, type FormLabelProps, Grid, type GridColDef, type GridProps, type GridRenderCellParams, type GridRenderHeaderParams, type GridRowSelectionModel, type GridValueFormatterParams, type GridValueGetterParams, H1, H2, H3, H4, H5, H6, HStack, IconButton, type IconButtonProps, IconRail, IconRailContent, type IconRailContentProps, IconRailFooter, type IconRailFooterProps, IconRailHeader, type IconRailHeaderProps, IconRailItem, type IconRailItemProps, type IconRailProps, Input, InputAdornment, type InputAdornmentProps, type InputProps, Label, type LabelProps, LinearProgress, type LinearProgressProps, List, ListDivider, type ListDividerProps, ListItem, ListItemAvatar, type ListItemAvatarProps, ListItemIcon, type ListItemIconProps, type ListItemProps, ListItemText, type ListItemTextProps, type ListProps, ListSubheader, type ListSubheaderProps, NativeSelect, NativeSelectOption, type NativeSelectOptionProps, type NativeSelectProps, PaginationNamespace as Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, type PaginationLinkProps, type PaginationModel, PaginationNext, PaginationPrevious, type PaginationProps, Playground, Progress, type ProgressProps, Radio, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, type RadioProps, RailPanel, RailPanelGroup, type RailPanelGroupProps, RailPanelItem, type RailPanelItemProps, type RailPanelProps, SelectNamespace as Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, type SeparatorProps, Sheet, SheetBody, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Sidebar, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarRail, type SidebarRailProps, SidebarSubMenu, type SidebarSubMenuProps, SidebarToggle, type SidebarToggleProps, Skeleton, SkeletonAvatar, type SkeletonAvatarProps, SkeletonCard, type SkeletonCardProps, type SkeletonProps, SkeletonTableRow, type SkeletonTableRowProps, SkeletonText, type SkeletonTextProps, Spinner, type SpinnerProps, Stack, type StackProps, Switch, type SwitchProps, TableNamespace as Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Text, TextField, type TextFieldProps, Textarea, type TextareaProps, ThemeContext, type ThemeContextValue, ThemeProvider, type ThemeProviderProps, Tooltip, TooltipArrow, TooltipContent, type TooltipContentProps, TooltipPortal, type TooltipProps, TooltipProvider, TooltipRoot, TooltipTrigger, TopBar, TopBarBrand, type TopBarBrandProps, TopBarDivider, type TopBarDividerProps, TopBarNav, TopBarNavItem, type TopBarNavItemProps, type TopBarNavProps, type TopBarProps, TopBarSection, type TopBarSectionProps, Typography, type TypographyProps, VStack, cn, useFormControl, useSidebar, useSidebarRail, useTheme };