@matheusrizzati/ui 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,7 +1,10 @@
 import { ClassValue } from 'clsx';
-import React, { ButtonHTMLAttributes, InputHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
+import React, { ButtonHTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes, ReactNode, HTMLAttributes, ImgHTMLAttributes } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
 import * as Dialog from '@radix-ui/react-dialog';
 import * as DropdownMenu from '@radix-ui/react-dropdown-menu';
 
@@ -11,6 +14,37 @@ import * as DropdownMenu from '@radix-ui/react-dropdown-menu';
  */
 declare function cn(...inputs: ClassValue[]): string;
 
+type Theme = "light" | "dark" | "system";
+interface ThemeContextValue {
+    /** The current theme setting ('light', 'dark', or 'system') */
+    theme: Theme;
+    /** The resolved theme after evaluating system preference */
+    resolvedTheme: "light" | "dark";
+    /** Set a specific theme */
+    setTheme: (theme: Theme) => void;
+    /** Toggle between light and dark */
+    toggleTheme: () => void;
+}
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    /** Default theme if nothing is stored. Defaults to 'system'. */
+    defaultTheme?: Theme;
+    /** localStorage key for persistence. Defaults to 'rizhel-theme'. */
+    storageKey?: string;
+    /** Force a specific theme, ignoring stored/default value. */
+    forcedTheme?: "light" | "dark";
+}
+declare function ThemeProvider({ children, defaultTheme, storageKey, forcedTheme, }: ThemeProviderProps): React.FunctionComponentElement<React.ProviderProps<ThemeContextValue | undefined>>;
+/**
+ * Hook to access the current theme and theme controls.
+ *
+ * @example
+ * ```tsx
+ * const { theme, resolvedTheme, toggleTheme } = useTheme();
+ * ```
+ */
+declare function useTheme(): ThemeContextValue;
+
 declare const buttonVariants: (props?: ({
     variant?: "primary" | "secondary" | "ghost" | "danger" | null | undefined;
     size?: "sm" | "md" | "lg" | "icon" | null | undefined;
@@ -38,11 +72,188 @@ interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">
     startIcon?: React.ReactNode;
     /** Content rendered at the end of the input */
     endIcon?: React.ReactNode;
+    /** Callback to clear the input value — shows a clear (×) button when provided and input has value */
+    onClear?: () => void;
 }
 declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
 
+declare const textareaVariants: (props?: ({
+    inputSize?: "sm" | "md" | "lg" | null | undefined;
+    state?: "default" | "error" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size">, VariantProps<typeof textareaVariants> {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    autoResize?: boolean;
+    showCount?: boolean;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    /** Optional icon or element to render before the label */
+    icon?: ReactNode;
+    /** Optional description text below the label */
+    description?: string;
+}
+interface SelectGroup {
+    label: string;
+    options: SelectOption[];
+}
+interface SelectProps {
+    /** Flat list of options */
+    options?: SelectOption[];
+    /** Grouped options — takes priority over `options` */
+    groups?: SelectGroup[];
+    /** Currently selected value */
+    value?: string;
+    /** Callback when value changes */
+    onChange?: (value: string) => void;
+    /** Placeholder text shown when nothing is selected */
+    placeholder?: string;
+    /** Label above the select */
+    label?: string;
+    /** Helper text below the select */
+    helperText?: string;
+    /** Error message — activates error styling */
+    error?: string;
+    /** No search results text */
+    emptyMessage?: string;
+    /** Enable search filtering */
+    searchable?: boolean;
+    /** Search input placeholder */
+    searchPlaceholder?: string;
+    /** Allow clearing the selected value */
+    clearable?: boolean;
+    /** Component size */
+    size?: "sm" | "md" | "lg";
+    /** Disable the select */
+    disabled?: boolean;
+    /** Additional class name */
+    className?: string;
+    /** Custom option renderer */
+    renderOption?: (option: SelectOption, isSelected: boolean) => ReactNode;
+}
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    /** Optional icon or element before label */
+    icon?: ReactNode;
+}
+interface ComboboxGroup {
+    label: string;
+    options: ComboboxOption[];
+}
+interface ComboboxProps {
+    /** Flat list of options */
+    options?: ComboboxOption[];
+    /** Grouped options — takes priority over `options` */
+    groups?: ComboboxGroup[];
+    /** Current value (string for single, string[] for multi) */
+    value?: string | string[];
+    /** Callback when value changes */
+    onChange?: (value: string | string[]) => void;
+    /** Input placeholder */
+    placeholder?: string;
+    /** Label text */
+    label?: string;
+    /** No results message */
+    emptyMessage?: string;
+    /** Allow multiple selections */
+    multiple?: boolean;
+    /** Allow creating new options on Enter */
+    creatable?: boolean;
+    /** Text for the create option (receives the search term) */
+    createLabel?: (search: string) => string;
+    /** Show loading spinner */
+    loading?: boolean;
+    /** Disable the combobox */
+    disabled?: boolean;
+    /** Additional class name */
+    className?: string;
+}
+declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const checkboxVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size">, VariantProps<typeof checkboxVariants> {
+    label?: string;
+    description?: string;
+    indeterminate?: boolean;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
+
+interface RadioGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    name?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    orientation?: "vertical" | "horizontal";
+    disabled?: boolean;
+}
+declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    label?: string;
+    description?: string;
+}
+declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
+
+interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    label?: string;
+    description?: string;
+    size?: "sm" | "md";
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface SeparatorProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | "xl" | null | undefined;
+    shape?: "circle" | "rounded" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface AvatarProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "size">, VariantProps<typeof avatarVariants> {
+    name?: string;
+    status?: "online" | "offline" | "busy" | "away";
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+interface TooltipProps {
+    children: ReactNode;
+    content: ReactNode;
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    delayDuration?: number;
+    sideOffset?: number;
+}
+declare function Tooltip({ children, content, side, align, delayDuration, sideOffset, }: TooltipProps): react_jsx_runtime.JSX.Element;
+declare namespace Tooltip {
+    var displayName: string;
+}
+
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverClose: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
 declare const cardVariants: (props?: ({
-    variant?: "ghost" | "elevated" | "outlined" | null | undefined;
+    variant?: "ghost" | "elevated" | "outlined" | "glass" | null | undefined;
     hoverable?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 
@@ -139,4 +350,325 @@ interface SidebarItemProps extends HTMLAttributes<HTMLButtonElement> {
 declare const SidebarItem: React.ForwardRefExoticComponent<SidebarItemProps & React.RefAttributes<HTMLButtonElement>>;
 declare const SidebarToggle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLButtonElement> & React.RefAttributes<HTMLButtonElement>>;
 
-export { Badge, type BadgeProps, Button, type ButtonProps, Card, CardBody, CardFooter, CardHeader, type CardProps, Dropdown, DropdownContent, DropdownGroup, DropdownItem, DropdownLabel, DropdownSeparator, DropdownTrigger, Input, type InputProps, Modal, ModalContent, type ModalContentProps, ModalDescription, ModalFooter, ModalTitle, ModalTrigger, Sidebar, SidebarContent, SidebarFooter, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarSection, type SidebarSectionProps, SidebarToggle, Table, TableWrapper, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsProps, TabsTrigger, type TabsTriggerProps, Tbody, Td, Th, Thead, Tr, badgeVariants, buttonVariants, cardVariants, cn, inputVariants, useSidebar };
+declare const statCardChangeVariants: (props?: ({
+    changeType?: "positive" | "negative" | "neutral" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface StatCardProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof statCardChangeVariants> {
+    title: string;
+    value: string | number;
+    change?: string;
+    changeType?: "positive" | "negative" | "neutral";
+    icon?: ReactNode;
+}
+declare const StatCard: React.ForwardRefExoticComponent<StatCardProps & React.RefAttributes<HTMLDivElement>>;
+
+interface EmptyStateProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: ReactNode;
+    title: string;
+    description?: string;
+    action?: ReactNode;
+}
+declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const alertVariants: (props?: ({
+    variant?: "danger" | "success" | "warning" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface AlertProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+    title?: string;
+    description?: string;
+    icon?: ReactNode;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    action?: ReactNode;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const skeletonVariants: (props?: ({
+    variant?: "circle" | "rect" | "text" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof skeletonVariants> {
+    width?: string | number;
+    height?: string | number;
+}
+interface SkeletonTextProps extends HTMLAttributes<HTMLDivElement> {
+    lines?: number;
+    lastLineWidth?: string;
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>> & {
+    Text: React.FC<SkeletonTextProps>;
+};
+
+declare const progressTrackVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const progressBarVariants: (props?: ({
+    variant?: "danger" | "default" | "success" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface ProgressProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof progressTrackVariants>, VariantProps<typeof progressBarVariants> {
+    value?: number;
+    max?: number;
+    label?: string;
+    showValue?: boolean;
+    indeterminate?: boolean;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+
+interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'> {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    showInfo?: boolean;
+    totalItems?: number;
+    pageSize?: number;
+}
+declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
+
+interface BreadcrumbProps extends HTMLAttributes<HTMLElement> {
+    separator?: ReactNode;
+}
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
+interface BreadcrumbItemProps extends HTMLAttributes<HTMLAnchorElement> {
+    href?: string;
+    active?: boolean;
+    icon?: ReactNode;
+}
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<BreadcrumbItemProps & React.RefAttributes<HTMLAnchorElement>>;
+
+interface ToastData {
+    id: string;
+    title?: string;
+    description?: string;
+    variant?: "default" | "success" | "warning" | "danger";
+    duration?: number;
+    action?: ReactNode;
+}
+type ToastInput = Omit<ToastData, "id">;
+interface ToastContextValue {
+    toast: (input: ToastInput) => void;
+    dismiss: (id: string) => void;
+}
+declare const useToast: () => ToastContextValue;
+declare function ToastProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare namespace ToastProvider {
+    var displayName: string;
+}
+
+interface Command {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    group?: string;
+    onAction: () => void;
+}
+interface CommandPaletteProps {
+    commands: Command[];
+    placeholder?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    emptyMessage?: string;
+}
+declare function CommandPalette({ commands, placeholder, open: controlledOpen, onOpenChange, emptyMessage, }: CommandPaletteProps): react_jsx_runtime.JSX.Element;
+declare namespace CommandPalette {
+    var displayName: string;
+}
+
+interface DataTableColumn<T = any> {
+    key: string;
+    header: string;
+    render?: (value: any, row: T, index: number) => ReactNode;
+    sortable?: boolean;
+    width?: string;
+    align?: "left" | "center" | "right";
+}
+interface DataTableProps<T = any> extends HTMLAttributes<HTMLDivElement> {
+    columns: DataTableColumn<T>[];
+    data: T[];
+    sortable?: boolean;
+    onSort?: (key: string, direction: "asc" | "desc") => void;
+    selectable?: boolean;
+    selectedRows?: Set<number>;
+    onSelectionChange?: (selected: Set<number>) => void;
+    emptyMessage?: string;
+    stickyHeader?: boolean;
+}
+declare const DataTable: <T extends Record<string, any>>(props: DataTableProps<T> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+
+interface StepData {
+    title: string;
+    description?: string;
+    icon?: ReactNode;
+}
+interface StepsProps extends HTMLAttributes<HTMLDivElement> {
+    steps: StepData[];
+    current: number;
+    orientation?: "horizontal" | "vertical";
+}
+declare const Steps: React.ForwardRefExoticComponent<StepsProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AppShellProps extends HTMLAttributes<HTMLDivElement> {
+    sidebar?: ReactNode;
+    navbar?: ReactNode;
+}
+declare const AppShell: React.ForwardRefExoticComponent<AppShellProps & React.RefAttributes<HTMLDivElement>>;
+
+interface PageHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    title: string;
+    description?: string;
+    breadcrumbs?: ReactNode;
+    actions?: ReactNode;
+}
+declare const PageHeader: React.ForwardRefExoticComponent<PageHeaderProps & React.RefAttributes<HTMLDivElement>>;
+
+interface NavbarProps extends HTMLAttributes<HTMLElement> {
+    leftContent?: ReactNode;
+    centerContent?: ReactNode;
+    rightContent?: ReactNode;
+}
+declare const Navbar: React.ForwardRefExoticComponent<NavbarProps & React.RefAttributes<HTMLElement>>;
+
+type DrawerSide = "left" | "right" | "top" | "bottom";
+type DrawerSize = "sm" | "md" | "lg" | "xl" | "full";
+interface DrawerProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: ReactNode;
+}
+interface DrawerContentProps {
+    children: ReactNode;
+    side?: DrawerSide;
+    size?: DrawerSize;
+    className?: string;
+}
+declare const Drawer: {
+    ({ children, ...props }: DrawerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerTrigger: React.ForwardRefExoticComponent<Dialog.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DrawerClose: React.ForwardRefExoticComponent<Dialog.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DrawerContent: React.ForwardRefExoticComponent<DrawerContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: ({ children, className, onClose, }: {
+    children: ReactNode;
+    className?: string;
+    onClose?: () => void;
+}) => react_jsx_runtime.JSX.Element;
+declare const DrawerTitle: ({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const DrawerDescription: ({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const DrawerBody: ({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const DrawerFooter: ({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+interface AccordionItemData {
+    value: string;
+    trigger: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+interface AccordionProps {
+    /** Accordion items */
+    items: AccordionItemData[];
+    /** 'single' allows one open at a time, 'multiple' allows many */
+    type?: "single" | "multiple";
+    /** Default open item value(s) */
+    defaultValue?: string | string[];
+    /** Additional className for the root */
+    className?: string;
+}
+declare function Accordion({ items, type, defaultValue, className, }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare namespace Accordion {
+    var displayName: string;
+}
+
+interface SliderProps {
+    /** Current value */
+    value?: number;
+    /** Callback when value changes */
+    onChange?: (value: number) => void;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Label text */
+    label?: string;
+    /** Show the current value */
+    showValue?: boolean;
+    /** Format the displayed value */
+    formatValue?: (value: number) => string;
+    /** Component size */
+    size?: "sm" | "md" | "lg";
+    /** Disable the slider */
+    disabled?: boolean;
+    /** Additional className */
+    className?: string;
+}
+declare function Slider({ value, onChange, min, max, step, label, showValue, formatValue, size, disabled, className, }: SliderProps): react_jsx_runtime.JSX.Element;
+declare namespace Slider {
+    var displayName: string;
+}
+
+interface AvatarGroupProps {
+    children: ReactNode;
+    /** Maximum avatars to show before +N */
+    max?: number;
+    /** Size matches Avatar sizes */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /** Additional className */
+    className?: string;
+}
+declare function AvatarGroup({ children, max, size, className }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace AvatarGroup {
+    var displayName: string;
+}
+
+interface ConfirmDialogProps {
+    /** Whether the dialog is open */
+    open?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Title text */
+    title: string;
+    /** Description text */
+    description?: string;
+    /** Confirm button text */
+    confirmText?: string;
+    /** Cancel button text */
+    cancelText?: string;
+    /** Variant for the confirm button */
+    variant?: "danger" | "primary";
+    /** Callback when confirmed */
+    onConfirm?: () => void;
+    /** Callback when cancelled */
+    onCancel?: () => void;
+    /** Trigger element (if controlled via trigger instead of open/onOpenChange) */
+    trigger?: ReactNode;
+    /** Whether action is in progress */
+    loading?: boolean;
+}
+declare function ConfirmDialog({ open, onOpenChange, title, description, confirmText, cancelText, variant, onConfirm, onCancel, trigger, loading, }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
+declare namespace ConfirmDialog {
+    var displayName: string;
+}
+
+export { Accordion, type AccordionItemData, type AccordionProps, Alert, type AlertProps, AppShell, type AppShellProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, Badge, type BadgeProps, Breadcrumb, BreadcrumbItem, type BreadcrumbItemProps, type BreadcrumbProps, Button, type ButtonProps, Card, CardBody, CardFooter, CardHeader, type CardProps, Checkbox, type CheckboxProps, Combobox, type ComboboxGroup, type ComboboxOption, type ComboboxProps, type Command, CommandPalette, type CommandPaletteProps, ConfirmDialog, type ConfirmDialogProps, DataTable, type DataTableColumn, type DataTableProps, Drawer, DrawerBody, DrawerClose, DrawerContent, type DrawerContentProps, DrawerDescription, DrawerFooter, DrawerHeader, type DrawerProps, type DrawerSide, type DrawerSize, DrawerTitle, DrawerTrigger, Dropdown, DropdownContent, DropdownGroup, DropdownItem, DropdownLabel, DropdownSeparator, DropdownTrigger, EmptyState, type EmptyStateProps, Input, type InputProps, Modal, ModalContent, type ModalContentProps, ModalDescription, ModalFooter, ModalTitle, ModalTrigger, Navbar, type NavbarProps, PageHeader, type PageHeaderProps, Pagination, type PaginationProps, Popover, PopoverAnchor, PopoverClose, PopoverContent, PopoverTrigger, Progress, type ProgressProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, Select, type SelectGroup, type SelectOption, type SelectProps, Separator, type SeparatorProps, Sidebar, SidebarContent, SidebarFooter, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarSection, type SidebarSectionProps, SidebarToggle, Skeleton, type SkeletonProps, Slider, type SliderProps, StatCard, type StatCardProps, type StepData, Steps, type StepsProps, Switch, type SwitchProps, Table, TableWrapper, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsProps, TabsTrigger, type TabsTriggerProps, Tbody, Td, Textarea, type TextareaProps, Th, Thead, type Theme, ThemeProvider, type ThemeProviderProps, type ToastData, ToastProvider, Tooltip, type TooltipProps, TooltipProvider, Tr, badgeVariants, buttonVariants, cardVariants, cn, inputVariants, textareaVariants, useSidebar, useTheme, useToast };