czero 0.1.0 → 0.2.5

package/dist/react/index.d.ts

@@ -1,16 +1,41 @@
 import * as React from 'react';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
 
 interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    variant?: "primary" | "secondary" | "outline" | "ghost" | "danger";
-    size?: "sm" | "md" | "lg";
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "danger" | "link";
+    size?: "sm" | "md" | "lg" | "icon";
     loading?: boolean;
+    fullWidth?: boolean;
+    asChild?: boolean;
 }
 declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
 
 interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
     label?: string;
-    error?: string;
-    size?: "sm" | "md" | "lg";
+    description?: string;
+    error?: boolean | string;
+    size?: "sm" | "md" | "lg" | "small" | "medium" | "large";
+    variant?: string;
+    icon?: React.ReactNode;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+    onClear?: () => void;
+    showPasswordToggle?: boolean;
 }
 declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
 
@@ -31,5 +56,510 @@ interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
 }
 declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
 
-export { Badge, Button, Card, Input };
-export type { BadgeProps, ButtonProps, CardProps, InputProps };
+type StatusTone = "primary" | "success" | "danger" | "warning";
+interface StatusBadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+    status?: React.ReactNode;
+    children?: React.ReactNode;
+    tone?: StatusTone;
+    showDot?: boolean;
+}
+declare const StatusBadge: React.ForwardRefExoticComponent<StatusBadgeProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+    label?: string;
+    description?: string;
+    error?: string;
+    size?: "sm" | "md" | "lg";
+    autoResize?: boolean;
+    maxRows?: number;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root> {
+    size?: "sm" | "md" | "lg";
+    label?: string;
+    description?: string;
+    labelPosition?: "left" | "right";
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: "sm" | "md" | "lg";
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface SeparatorProps extends React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root> {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "info" | "success" | "warning" | "danger";
+    title?: string;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+
+interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    label?: string;
+    description?: string;
+    size?: "sm" | "md" | "lg";
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface TooltipProps {
+    content: React.ReactNode;
+    children: React.ReactElement;
+    side?: "top" | "bottom" | "left" | "right";
+    align?: "start" | "center" | "end";
+    delayDuration?: number;
+    /** @deprecated Use `side` instead */
+    position?: "top" | "bottom" | "left" | "right";
+    /** @deprecated Use `delayDuration` instead */
+    delay?: number;
+}
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ProgressProps extends React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
+    value?: number;
+    max?: number;
+    size?: "sm" | "md" | "lg";
+    variant?: "default" | "success" | "warning" | "danger";
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "text" | "circular" | "rectangular";
+    width?: string | number;
+    height?: string | number;
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+
+type TabsValue = string | number | boolean;
+type TabsVariant = "underline" | "pills" | "enclosed";
+type TabsSize = "sm" | "md" | "lg" | "small" | "medium" | "large";
+interface TabsItem {
+    value: TabsValue;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    count?: React.ReactNode;
+    disabled?: boolean;
+    content?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+interface TabsProps extends Omit<React.ComponentPropsWithoutRef<typeof TabsPrimitive.Root>, "value" | "defaultValue" | "onValueChange" | "onChange"> {
+    defaultValue?: TabsValue;
+    value?: TabsValue;
+    activeTab?: TabsValue;
+    onValueChange?: (value: string) => void;
+    onChange?: (value: TabsValue) => void;
+    setActiveTab?: (value: TabsValue) => void;
+    items?: TabsItem[];
+    tabs?: TabsItem[];
+    renderItem?: (item: TabsItem, state: {
+        isActive: boolean;
+    }) => React.ReactNode;
+    renderContent?: (item: TabsItem, state: {
+        isActive: boolean;
+    }) => React.ReactNode;
+    variant?: TabsVariant;
+    size?: TabsSize;
+    fullWidth?: boolean;
+    showBorder?: boolean;
+    disabled?: boolean;
+    listClassName?: string;
+    listStyle?: React.CSSProperties;
+    triggerClassName?: string;
+    triggerStyle?: React.CSSProperties;
+}
+interface TabsListProps extends React.ComponentPropsWithoutRef<typeof TabsPrimitive.List> {
+}
+interface TabsTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>, "value"> {
+    value: TabsValue;
+    icon?: React.ReactNode;
+    count?: React.ReactNode;
+}
+interface TabsContentProps extends Omit<React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>, "value"> {
+    value: TabsValue;
+}
+declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>> & {
+    List: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+};
+
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+    modal?: boolean;
+}
+interface DialogTriggerProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Trigger> {
+    asChild?: boolean;
+}
+interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+}
+interface DialogHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface DialogFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const Dialog: React.FC<DialogProps> & {
+    Trigger: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+    Header: React.ForwardRefExoticComponent<DialogHeaderProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Footer: React.ForwardRefExoticComponent<DialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+    Close: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Overlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+
+type ModalSize = "sm" | "md" | "lg" | "xl" | "full";
+type ModalCloseButtonVariant = "icon" | "button";
+interface ModalTabItem {
+    id: string;
+    name?: React.ReactNode;
+    label?: React.ReactNode;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+interface ModalProps extends Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, "children" | "title"> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    isOpen?: boolean;
+    onClose?: () => void;
+    modal?: boolean;
+    trigger?: React.ReactNode;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    tabs?: ModalTabItem[];
+    activeTab?: string;
+    onTabChange?: (tabId: string) => void;
+    hideTitle?: boolean;
+    size?: ModalSize;
+    width?: number | string;
+    minHeight?: number | string;
+    fullHeight?: boolean;
+    showCloseButton?: boolean;
+    closeButtonVariant?: ModalCloseButtonVariant;
+    closeButtonText?: string;
+    closeOnOverlay?: boolean;
+    closeOnEsc?: boolean;
+    portalContainer?: HTMLElement;
+    overlayClassName?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+}
+declare const Modal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SelectProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    children: React.ReactNode;
+    /** @deprecated Use SelectItem children instead */
+    options?: Array<{
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }>;
+    label?: string;
+    error?: string;
+    size?: "sm" | "md" | "lg";
+}
+declare const Select: React.FC<SelectProps> & {
+    Trigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Separator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Group: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+    Value: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+};
+
+interface RadioGroupProps extends React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> {
+    orientation?: "horizontal" | "vertical";
+    /** @deprecated Use standard name attribute on form instead */
+    name?: string;
+}
+interface RadioGroupItemProps extends React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item> {
+    label?: string;
+    description?: string;
+}
+declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>> & {
+    Item: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+interface TableProps extends React.TableHTMLAttributes<HTMLTableElement> {
+    children: React.ReactNode;
+}
+interface TableHeaderProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+    children: React.ReactNode;
+}
+interface TableBodyProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+    children: React.ReactNode;
+}
+interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    children: React.ReactNode;
+}
+interface TableHeadProps extends React.ThHTMLAttributes<HTMLTableCellElement> {
+    children?: React.ReactNode;
+}
+interface TableCellProps extends React.TdHTMLAttributes<HTMLTableCellElement> {
+    children?: React.ReactNode;
+}
+declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLTableElement>> & {
+    Header: React.ForwardRefExoticComponent<TableHeaderProps & React.RefAttributes<HTMLTableSectionElement>>;
+    Body: React.ForwardRefExoticComponent<TableBodyProps & React.RefAttributes<HTMLTableSectionElement>>;
+    Row: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLTableRowElement>>;
+    Head: React.ForwardRefExoticComponent<TableHeadProps & React.RefAttributes<HTMLTableCellElement>>;
+    Cell: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
+};
+
+type DataTableRow = Record<string, unknown>;
+type DataTableRowId = string | number;
+type DataTableSortDirection = "asc" | "desc";
+type DataTableAlign = "left" | "center" | "right";
+interface DataTableColumn {
+    key: string;
+    header: React.ReactNode;
+    render?: (row: DataTableRow, value: unknown) => React.ReactNode;
+    sortable?: boolean;
+    align?: DataTableAlign;
+    width?: React.CSSProperties["width"];
+    className?: string;
+    customHeaderRender?: () => React.ReactNode;
+}
+interface DataTableProps extends React.HTMLAttributes<HTMLDivElement> {
+    data?: DataTableRow[];
+    columns?: DataTableColumn[];
+    selectable?: boolean;
+    selectedRows?: DataTableRowId[];
+    onSelectionChange?: (selectedRows: DataTableRowId[]) => void;
+    sortable?: boolean;
+    defaultSortKey?: string | null;
+    defaultSortDir?: DataTableSortDirection;
+    pagination?: boolean;
+    pageSize?: number;
+    currentPage?: number;
+    onPageChange?: (page: number) => void;
+    loading?: boolean;
+    isLoading?: boolean;
+    emptyState?: React.ReactNode;
+    emptyMessage?: string;
+    onRowClick?: (row: DataTableRow) => void;
+    getRowId?: (row: DataTableRow, index: number) => DataTableRowId;
+    variant?: "default" | "striped" | "bordered";
+}
+declare const DataTable: React.ForwardRefExoticComponent<DataTableProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AccordionSingleProps extends React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Root> {
+    type?: "single";
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    collapsible?: boolean;
+}
+interface AccordionMultipleProps extends React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Root> {
+    type: "multiple";
+    defaultValue?: string[];
+    value?: string[];
+    onValueChange?: (value: string[]) => void;
+}
+type AccordionProps = AccordionSingleProps | AccordionMultipleProps;
+interface AccordionItemProps extends React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item> {
+    value: string;
+}
+interface AccordionTriggerProps extends React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger> {
+}
+interface AccordionContentProps extends React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content> {
+}
+declare const Accordion: React.ForwardRefExoticComponent<AccordionProps & React.RefAttributes<HTMLDivElement>> & {
+    Item: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
+    Header: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionHeaderProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+    Trigger: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
+};
+
+interface StackProps extends React.HTMLAttributes<HTMLDivElement> {
+    direction?: "row" | "column";
+    gap?: "xs" | "sm" | "md" | "lg" | "xl";
+    align?: "start" | "center" | "end" | "stretch";
+    justify?: "start" | "center" | "end" | "between" | "around";
+    wrap?: boolean;
+    children: React.ReactNode;
+}
+declare const Stack: React.ForwardRefExoticComponent<StackProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SpinnerProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: "sm" | "md" | "lg";
+    variant?: "default" | "primary";
+}
+declare const Spinner: React.ForwardRefExoticComponent<SpinnerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AspectRatioProps extends React.ComponentPropsWithoutRef<typeof AspectRatioPrimitive.Root> {
+    ratio?: number;
+    children: React.ReactNode;
+}
+declare const AspectRatio: React.ForwardRefExoticComponent<AspectRatioProps & React.RefAttributes<HTMLDivElement>>;
+
+interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+}
+interface BreadcrumbListProps extends React.HTMLAttributes<HTMLOListElement> {
+    children: React.ReactNode;
+}
+interface BreadcrumbItemProps extends React.HTMLAttributes<HTMLLIElement> {
+    children: React.ReactNode;
+}
+interface BreadcrumbLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    children: React.ReactNode;
+    asChild?: boolean;
+}
+interface BreadcrumbSeparatorProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children?: React.ReactNode;
+}
+interface BreadcrumbPageProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children: React.ReactNode;
+}
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>> & {
+    List: React.ForwardRefExoticComponent<BreadcrumbListProps & React.RefAttributes<HTMLOListElement>>;
+    Item: React.ForwardRefExoticComponent<BreadcrumbItemProps & React.RefAttributes<HTMLLIElement>>;
+    Link: React.ForwardRefExoticComponent<BreadcrumbLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+    Separator: React.ForwardRefExoticComponent<BreadcrumbSeparatorProps & React.RefAttributes<HTMLSpanElement>>;
+    Page: React.ForwardRefExoticComponent<BreadcrumbPageProps & React.RefAttributes<HTMLSpanElement>>;
+};
+
+interface LabelProps extends React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> {
+    required?: boolean;
+}
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+
+interface VisuallyHiddenProps extends React.ComponentPropsWithoutRef<typeof VisuallyHiddenPrimitive.Root> {
+    children: React.ReactNode;
+}
+declare const VisuallyHidden: React.ForwardRefExoticComponent<VisuallyHiddenProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface ContainerProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    centered?: boolean;
+    children: React.ReactNode;
+}
+declare const Container: React.ForwardRefExoticComponent<ContainerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface GridProps extends React.HTMLAttributes<HTMLDivElement> {
+    cols?: 1 | 2 | 3 | 4 | 5 | 6 | 12;
+    gap?: "xs" | "sm" | "md" | "lg" | "xl";
+    children: React.ReactNode;
+}
+declare const Grid: React.ForwardRefExoticComponent<GridProps & React.RefAttributes<HTMLDivElement>>;
+
+interface KbdProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+}
+declare const Kbd: React.ForwardRefExoticComponent<KbdProps & React.RefAttributes<HTMLElement>>;
+
+interface CodeProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+}
+declare const Code: React.ForwardRefExoticComponent<CodeProps & React.RefAttributes<HTMLElement>>;
+
+interface ScrollAreaProps extends React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root> {
+    maxHeight?: string | number;
+    children: React.ReactNode;
+}
+declare const ScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+
+interface DropdownMenuProps {
+    children: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+}
+interface DropdownMenuTriggerProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Trigger> {
+    asChild?: boolean;
+}
+interface DropdownMenuContentProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> {
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+}
+interface DropdownMenuItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> {
+    inset?: boolean;
+}
+interface DropdownMenuCheckboxItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem> {
+}
+declare const DropdownMenu: React.FC<DropdownMenuProps> & {
+    Trigger: React.ForwardRefExoticComponent<DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+    Separator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    CheckboxItem: React.ForwardRefExoticComponent<DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+    Sub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+    SubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    SubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+
+interface ToastProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "default" | "success" | "warning" | "danger";
+    title?: string;
+    description?: string;
+    onClose?: () => void;
+}
+interface ToasterProps {
+    position?: "top-left" | "top-right" | "top-center" | "bottom-left" | "bottom-right" | "bottom-center";
+}
+interface ToastItem {
+    id: string;
+    variant?: ToastProps["variant"];
+    title?: string;
+    description?: string;
+    duration?: number;
+}
+declare const useToast: () => {
+    toast: (options: Omit<ToastItem, "id">) => void;
+    toasts: ToastItem[];
+};
+declare const ToastProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+declare const Toast: React.ForwardRefExoticComponent<ToastProps & React.RefAttributes<HTMLDivElement>>;
+declare const Toaster: React.FC<ToasterProps>;
+
+interface TagProps extends React.HTMLAttributes<HTMLSpanElement> {
+    variant?: "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+    size?: "sm" | "md" | "lg";
+    removable?: boolean;
+    onRemove?: () => void;
+    children: React.ReactNode;
+}
+declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLSpanElement>>;
+
+type Theme = "light" | "dark" | "system";
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+}
+interface ThemeContextValue {
+    theme: Theme;
+    resolvedTheme: "light" | "dark";
+    setTheme: (theme: Theme) => void;
+    toggleTheme: () => void;
+}
+declare const ThemeProvider: React.FC<ThemeProviderProps>;
+declare function useTheme(): ThemeContextValue;
+
+export { Accordion, Alert, AspectRatio, Avatar, Badge, Breadcrumb, Button, Card, Checkbox, Code, Container, DataTable, Dialog, DropdownMenu, Grid, Input, Kbd, Label, Modal, Progress, RadioGroup, ScrollArea, Select, Separator, Skeleton, Spinner, Stack, StatusBadge, Switch, Table, Tabs, Tag, Textarea, ThemeProvider, Toast, ToastProvider, Toaster, Tooltip, TooltipProvider, VisuallyHidden, useTheme, useToast };
+export type { AccordionContentProps, AccordionItemProps, AccordionProps, AccordionTriggerProps, AlertProps, AspectRatioProps, AvatarProps, BadgeProps, BreadcrumbItemProps, BreadcrumbLinkProps, BreadcrumbListProps, BreadcrumbPageProps, BreadcrumbProps, BreadcrumbSeparatorProps, ButtonProps, CardProps, CheckboxProps, CodeProps, ContainerProps, DataTableAlign, DataTableColumn, DataTableProps, DataTableSortDirection, DialogContentProps, DialogFooterProps, DialogHeaderProps, DialogProps, DialogTriggerProps, DropdownMenuCheckboxItemProps, DropdownMenuContentProps, DropdownMenuItemProps, DropdownMenuProps, DropdownMenuTriggerProps, GridProps, InputProps, KbdProps, LabelProps, ModalCloseButtonVariant, ModalProps, ModalSize, ProgressProps, RadioGroupItemProps, RadioGroupProps, ScrollAreaProps, SelectProps, SeparatorProps, SkeletonProps, SpinnerProps, StackProps, StatusBadgeProps, SwitchProps, TableBodyProps, TableCellProps, TableHeadProps, TableHeaderProps, TableProps, TableRowProps, TabsContentProps, TabsItem, TabsListProps, TabsProps, TabsSize, TabsTriggerProps, TabsValue, TabsVariant, TagProps, TextareaProps, Theme, ThemeContextValue, ThemeProviderProps, ToastProps, ToasterProps, TooltipProps, VisuallyHiddenProps };