atlasui-lib 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1027 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import React__default from 'react';
+export { useId } from 'react';
+import { VariantProps } from 'class-variance-authority';
+export { VariantProps } from 'class-variance-authority';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as ToastPrimitive from '@radix-ui/react-toast';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { ClassValue } from 'clsx';
+import * as tailwindcss_types_config from 'tailwindcss/types/config';
+import { Config } from 'tailwindcss';
+
+declare const buttonVariants: (props?: ({
+    variant?: "solid" | "outline" | "ghost" | "soft" | "link" | "danger" | "success" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "icon" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+    loading?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    /** Render as child element (Radix Slot pattern) */
+    asChild?: boolean;
+    /** Show loading spinner */
+    loading?: boolean;
+    /** Left icon slot */
+    leftIcon?: React.ReactNode;
+    /** Right icon slot */
+    rightIcon?: React.ReactNode;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const iconButtonVariants: (props?: ({
+    variant?: "solid" | "outline" | "ghost" | "soft" | "danger" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    shape?: "circle" | "square" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof iconButtonVariants> {
+    /** Accessible label — required for screen readers */
+    "aria-label": string;
+    asChild?: boolean;
+    icon?: React.ReactNode;
+}
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    asChild?: boolean;
+    external?: boolean;
+    underline?: "always" | "hover" | "none";
+}
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const badgeVariants: (props?: ({
+    variant?: "solid" | "outline" | "soft" | "neutral" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    color?: "danger" | "success" | "neutral" | "primary" | "warning" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "color">, VariantProps<typeof badgeVariants> {
+    dot?: boolean;
+}
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+declare const avatarSizes: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+};
+interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: keyof typeof avatarSizes;
+    shape?: "circle" | "square";
+    status?: "online" | "offline" | "busy" | "away";
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+interface AvatarGroupProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "size"> {
+    max?: number;
+    size?: AvatarProps["size"];
+    spacing?: "tight" | "normal" | "loose";
+}
+declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface DividerProps extends React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root> {
+    label?: React.ReactNode;
+    labelPosition?: "left" | "center" | "right";
+}
+declare const Divider: React.ForwardRefExoticComponent<DividerProps & React.RefAttributes<HTMLDivElement>>;
+interface TagProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "color" | "size"> {
+    closable?: boolean;
+    onClose?: () => void;
+    icon?: React.ReactNode;
+    size?: "sm" | "md" | "lg";
+    variant?: "solid" | "outline" | "soft";
+    color?: "primary" | "success" | "warning" | "danger" | "neutral";
+}
+declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLSpanElement>>;
+interface ChipProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    selected?: boolean;
+    avatar?: React.ReactNode;
+    icon?: React.ReactNode;
+    closable?: boolean;
+    onClose?: (e: React.MouseEvent) => void;
+    size?: "sm" | "md" | "lg";
+}
+declare const Chip: React.ForwardRefExoticComponent<ChipProps & React.RefAttributes<HTMLButtonElement>>;
+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 TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface TooltipProps {
+    content: React.ReactNode;
+    children: React.ReactNode;
+    side?: "top" | "right" | "bottom" | "left";
+    delayDuration?: number;
+    className?: string;
+}
+declare const Tooltip: {
+    ({ content, children, side, delayDuration, className }: TooltipProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ContainerProps extends React.HTMLAttributes<HTMLDivElement> {
+    maxWidth?: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+    center?: boolean;
+    padded?: boolean;
+}
+declare const Container: React.ForwardRefExoticComponent<ContainerProps & React.RefAttributes<HTMLDivElement>>;
+interface StackProps extends React.HTMLAttributes<HTMLDivElement> {
+    direction?: "row" | "column";
+    gap?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16;
+    align?: "start" | "center" | "end" | "stretch" | "baseline";
+    justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    wrap?: boolean;
+    divider?: React.ReactNode;
+}
+declare const Stack: React.ForwardRefExoticComponent<StackProps & React.RefAttributes<HTMLDivElement>>;
+interface GridProps extends React.HTMLAttributes<HTMLDivElement> {
+    cols?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    gap?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12;
+    rows?: number;
+    flow?: "row" | "col" | "dense";
+}
+declare const Grid: React.ForwardRefExoticComponent<GridProps & React.RefAttributes<HTMLDivElement>>;
+interface FlexProps extends React.HTMLAttributes<HTMLDivElement> {
+    direction?: "row" | "col" | "row-reverse" | "col-reverse";
+    align?: "start" | "center" | "end" | "stretch" | "baseline";
+    justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    wrap?: boolean | "reverse";
+    gap?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12;
+    inline?: boolean;
+}
+declare const Flex: React.ForwardRefExoticComponent<FlexProps & React.RefAttributes<HTMLDivElement>>;
+interface SectionProps extends React.HTMLAttributes<HTMLElement> {
+    as?: React.ElementType;
+    py?: "sm" | "md" | "lg" | "xl" | "2xl";
+}
+declare const Section: React.ForwardRefExoticComponent<SectionProps & React.RefAttributes<HTMLElement>>;
+interface SpacerProps {
+    size?: 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24;
+    axis?: "horizontal" | "vertical" | "both";
+    className?: string;
+}
+declare const Spacer: {
+    ({ size, axis, className }: SpacerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const AspectRatio: React.ForwardRefExoticComponent<Omit<AspectRatioPrimitive.AspectRatioProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface CenterProps extends React.HTMLAttributes<HTMLDivElement> {
+    inline?: boolean;
+    minH?: string;
+}
+declare const Center: React.ForwardRefExoticComponent<CenterProps & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    orientation?: "vertical" | "horizontal" | "both";
+} & React.RefAttributes<HTMLDivElement>>;
+interface MasonryProps extends React.HTMLAttributes<HTMLDivElement> {
+    columns?: number | {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    gap?: number;
+}
+declare const Masonry: React.ForwardRefExoticComponent<MasonryProps & React.RefAttributes<HTMLDivElement>>;
+
+interface NavbarProps extends React.HTMLAttributes<HTMLElement> {
+    sticky?: boolean;
+    bordered?: boolean;
+    blurred?: boolean;
+}
+declare const Navbar: React.ForwardRefExoticComponent<NavbarProps & React.RefAttributes<HTMLElement>>;
+interface SidebarProps extends React.HTMLAttributes<HTMLElement> {
+    collapsible?: boolean;
+    collapsed?: boolean;
+    width?: string;
+    side?: "left" | "right";
+}
+declare const Sidebar: React.ForwardRefExoticComponent<SidebarProps & React.RefAttributes<HTMLElement>>;
+interface MenuItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    icon?: React.ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    badge?: React.ReactNode;
+    as?: React.ElementType;
+    href?: string;
+}
+declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const Menu: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+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>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    destructive?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+interface BreadcrumbItem {
+    label: React.ReactNode;
+    href?: string;
+    current?: boolean;
+}
+interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
+    items: BreadcrumbItem[];
+    separator?: React.ReactNode;
+}
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
+interface PaginationProps extends React.HTMLAttributes<HTMLElement> {
+    total: number;
+    page: number;
+    pageSize?: number;
+    onPageChange?: (page: number) => void;
+    siblingCount?: number;
+    showEdges?: boolean;
+}
+declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: "line" | "pills" | "enclosed";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    variant?: "line" | "pills" | "enclosed";
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface StepperStep {
+    title: string;
+    description?: string;
+    icon?: React.ReactNode;
+}
+interface StepperProps extends React.HTMLAttributes<HTMLDivElement> {
+    steps: StepperStep[];
+    current: number;
+    orientation?: "horizontal" | "vertical";
+}
+declare const Stepper: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const inputVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    invalid?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputVariants> {
+    leftElement?: React.ReactNode;
+    rightElement?: React.ReactNode;
+    invalid?: boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+interface TextAreaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    invalid?: boolean;
+    resize?: "none" | "both" | "horizontal" | "vertical";
+}
+declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    invalid?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    label?: React.ReactNode;
+    description?: string;
+    invalid?: boolean;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+interface RadioOption {
+    value: string;
+    label: React.ReactNode;
+    description?: string;
+    disabled?: boolean;
+}
+interface RadioGroupProps extends React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> {
+    options?: RadioOption[];
+    orientation?: "horizontal" | "vertical";
+}
+declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root> {
+    label?: React.ReactNode;
+    description?: string;
+    size?: "sm" | "md" | "lg";
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const RangeSlider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+interface DatePickerProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    label?: string;
+    invalid?: boolean;
+}
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLInputElement>>;
+interface TimePickerProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    label?: string;
+    invalid?: boolean;
+}
+declare const TimePicker: React.ForwardRefExoticComponent<TimePickerProps & React.RefAttributes<HTMLInputElement>>;
+
+interface FileUploadProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> {
+    label?: string;
+    hint?: string;
+    accept?: string;
+    maxSize?: number;
+    onFilesChange?: (files: File[]) => void;
+    dragDrop?: boolean;
+}
+declare const FileUpload: React.ForwardRefExoticComponent<FileUploadProps & React.RefAttributes<HTMLInputElement>>;
+interface OTPInputProps {
+    length?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    invalid?: boolean;
+    className?: string;
+    inputClassName?: string;
+}
+declare const OTPInput: React.ForwardRefExoticComponent<OTPInputProps & React.RefAttributes<HTMLDivElement>>;
+interface ColorPickerProps {
+    value?: string;
+    onChange?: (color: string) => void;
+    swatches?: string[];
+    className?: string;
+}
+declare const ColorPicker: {
+    ({ value, onChange, swatches, className }: ColorPickerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface SearchInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    onClear?: () => void;
+    loading?: boolean;
+    size?: "sm" | "md" | "lg";
+}
+declare const SearchInput: React.ForwardRefExoticComponent<SearchInputProps & React.RefAttributes<HTMLInputElement>>;
+interface PasswordInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    invalid?: boolean;
+    size?: "sm" | "md" | "lg";
+}
+declare const PasswordInput: React.ForwardRefExoticComponent<PasswordInputProps & React.RefAttributes<HTMLInputElement>>;
+interface FormFieldProps extends React.HTMLAttributes<HTMLDivElement> {
+    required?: boolean;
+}
+declare const FormField: React.ForwardRefExoticComponent<FormFieldProps & React.RefAttributes<HTMLDivElement>>;
+interface FormLabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
+    required?: boolean;
+    optional?: boolean;
+}
+declare const FormLabel: React.ForwardRefExoticComponent<FormLabelProps & React.RefAttributes<HTMLLabelElement>>;
+interface FormErrorProps extends React.HTMLAttributes<HTMLParagraphElement> {
+}
+declare const FormError: React.ForwardRefExoticComponent<FormErrorProps & React.RefAttributes<HTMLParagraphElement>>;
+interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface ComboboxProps {
+    options: ComboboxOption[];
+    value?: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    className?: string;
+    disabled?: boolean;
+}
+declare const Combobox: {
+    ({ options, value, onChange, placeholder, searchPlaceholder, emptyText, className, disabled }: ComboboxProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface MultiSelectProps {
+    options: ComboboxOption[];
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    maxDisplay?: number;
+    className?: string;
+}
+declare const MultiSelect: {
+    ({ options, value, onChange, placeholder, maxDisplay, className }: MultiSelectProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const cardVariants: (props?: ({
+    variant?: "outline" | "ghost" | "default" | "filled" | "elevated" | null | undefined;
+    interactive?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CardProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardVariants> {
+}
+declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+interface DataTableColumn<T> {
+    key: keyof T | string;
+    header: React.ReactNode;
+    cell?: (row: T, index: number) => React.ReactNode;
+    sortable?: boolean;
+    width?: string | number;
+    align?: "left" | "center" | "right";
+}
+interface DataTableProps<T extends Record<string, unknown>> {
+    data: T[];
+    columns: DataTableColumn<T>[];
+    loading?: boolean;
+    emptyText?: string;
+    onSort?: (key: string, direction: "asc" | "desc") => void;
+    striped?: boolean;
+    bordered?: boolean;
+    className?: string;
+    caption?: string;
+}
+declare function DataTable<T extends Record<string, unknown>>({ data, columns, loading, emptyText, onSort, striped, bordered, className, caption, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace DataTable {
+    var displayName: string;
+}
+interface ListProps extends Omit<React.HTMLAttributes<HTMLUListElement>, "color"> {
+    variant?: "simple" | "bordered" | "divided";
+    spacing?: "none" | "sm" | "md" | "lg";
+}
+declare const List: React.ForwardRefExoticComponent<ListProps & React.RefAttributes<HTMLUListElement>>;
+interface ListItemProps extends React.HTMLAttributes<HTMLLIElement> {
+    icon?: React.ReactNode;
+    extra?: React.ReactNode;
+    active?: boolean;
+}
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLLIElement>>;
+interface StatisticProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "prefix"> {
+    label: React.ReactNode;
+    value: React.ReactNode;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    trend?: {
+        value: number;
+        label?: string;
+    };
+    loading?: boolean;
+}
+declare const Statistic: React.ForwardRefExoticComponent<StatisticProps & React.RefAttributes<HTMLDivElement>>;
+interface TimelineEvent {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    time?: React.ReactNode;
+    icon?: React.ReactNode;
+    color?: "default" | "primary" | "success" | "warning" | "danger";
+}
+interface TimelineProps extends React.HTMLAttributes<HTMLOListElement> {
+    events: TimelineEvent[];
+}
+declare const Timeline: React.ForwardRefExoticComponent<TimelineProps & React.RefAttributes<HTMLOListElement>>;
+interface CalendarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    highlightedDates?: Date[];
+}
+declare const Calendar: React.ForwardRefExoticComponent<CalendarProps & React.RefAttributes<HTMLDivElement>>;
+interface CodeBlockProps extends React.HTMLAttributes<HTMLDivElement> {
+    code: string;
+    language?: string;
+    showLineNumbers?: boolean;
+    caption?: string;
+    onCopy?: () => void;
+}
+declare const CodeBlock: React.ForwardRefExoticComponent<CodeBlockProps & React.RefAttributes<HTMLDivElement>>;
+interface ChartProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    title?: string;
+    description?: string;
+    loading?: boolean;
+    empty?: boolean;
+}
+declare const Chart: React.ForwardRefExoticComponent<ChartProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const alertVariants: (props?: ({
+    variant?: "danger" | "success" | "warning" | "info" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+    icon?: React.ReactNode;
+    closable?: boolean;
+    onClose?: () => void;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const ToastProvider: React.FC<ToastPrimitive.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "danger" | "success" | "warning" | "info" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+interface SnackbarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "color"> {
+    open?: boolean;
+    message: React.ReactNode;
+    action?: React.ReactNode;
+    variant?: "default" | "success" | "warning" | "danger";
+    position?: "bottom-center" | "bottom-left" | "bottom-right" | "top-center";
+}
+declare const Snackbar: React.ForwardRefExoticComponent<SnackbarProps & React.RefAttributes<HTMLDivElement>>;
+interface ProgressProps extends React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
+    label?: string;
+    showValue?: boolean;
+    size?: "sm" | "md" | "lg";
+    color?: "default" | "success" | "warning" | "danger";
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+interface CircularProgressProps extends React.SVGAttributes<SVGElement> {
+    value?: number;
+    size?: number;
+    thickness?: number;
+    showValue?: boolean;
+    label?: string;
+    color?: "default" | "success" | "warning" | "danger";
+    indeterminate?: boolean;
+}
+declare const CircularProgress: {
+    ({ value, size, thickness, showValue, label, color, indeterminate, className, ...props }: CircularProgressProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface SkeletonProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "color"> {
+    variant?: "text" | "rect" | "circle";
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+interface LoadingSpinnerProps extends React.SVGAttributes<SVGElement> {
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    label?: string;
+}
+declare const LoadingSpinner: {
+    ({ size, label, className, ...props }: LoadingSpinnerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    icon?: React.ReactNode;
+    title: string;
+    description?: string;
+    action?: React.ReactNode;
+}
+declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+interface StatusIndicatorProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "color" | "size"> {
+    status: "online" | "offline" | "busy" | "away" | "idle";
+    label?: string;
+    pulse?: boolean;
+    size?: "sm" | "md" | "lg";
+}
+declare const StatusIndicator: React.ForwardRefExoticComponent<StatusIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+interface NotificationProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    avatar?: React.ReactNode;
+    icon?: React.ReactNode;
+    time?: React.ReactNode;
+    unread?: boolean;
+    onClose?: () => void;
+}
+declare const Notification: React.ForwardRefExoticComponent<NotificationProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    showClose?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+interface ModalProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footer?: React.ReactNode;
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    children?: React.ReactNode;
+    showClose?: boolean;
+}
+declare const Modal: {
+    ({ open, onOpenChange, title, description, footer, size, children, showClose }: ModalProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface DrawerProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: "left" | "right" | "top" | "bottom";
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footer?: React.ReactNode;
+    children?: React.ReactNode;
+    size?: "sm" | "md" | "lg" | "full";
+}
+declare const Drawer: {
+    ({ open, onOpenChange, side, title, description, footer, children, size }: DrawerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const Sheet: {
+    ({ open, onOpenChange, side, title, description, footer, children, size }: DrawerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const HoverCard: React.FC<HoverCardPrimitive.HoverCardProps>;
+declare const HoverCardTrigger: React.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const HoverCardContent: React.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    destructive?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+interface CommandDialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placeholder?: string;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare const CommandDialog: {
+    ({ open, onOpenChange, placeholder, children, className }: CommandDialogProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface LightboxProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    src: string;
+    alt?: string;
+    caption?: string;
+}
+declare const Lightbox: {
+    ({ open, onOpenChange, src, alt, caption }: LightboxProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ImageViewer: {
+    ({ open, onOpenChange, src, alt, caption }: LightboxProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
+    fallback?: React.ReactNode;
+    aspectRatio?: "square" | "video" | "portrait" | "landscape" | string;
+    fit?: "cover" | "contain" | "fill" | "none" | "scale-down";
+    rounded?: "none" | "sm" | "md" | "lg" | "xl" | "full";
+    loading?: "lazy" | "eager";
+    caption?: string;
+}
+declare const Image: React.ForwardRefExoticComponent<ImageProps & React.RefAttributes<HTMLImageElement>>;
+interface VideoPlayerProps extends React.VideoHTMLAttributes<HTMLVideoElement> {
+    src: string;
+    poster?: string;
+    aspectRatio?: "square" | "video" | "portrait" | "landscape";
+    rounded?: "none" | "sm" | "md" | "lg" | "xl";
+    caption?: string;
+    tracks?: {
+        src: string;
+        kind: "subtitles" | "captions" | "descriptions" | "chapters" | "metadata";
+        srcLang: string;
+        label: string;
+        default?: boolean;
+    }[];
+}
+declare const VideoPlayer: React.ForwardRefExoticComponent<VideoPlayerProps & React.RefAttributes<HTMLVideoElement>>;
+interface AudioPlayerProps extends Omit<React.AudioHTMLAttributes<HTMLAudioElement>, "title"> {
+    src: string;
+    title?: string;
+    artist?: string;
+    coverArt?: string;
+    showWaveform?: boolean;
+}
+declare const AudioPlayer: React.ForwardRefExoticComponent<AudioPlayerProps & React.RefAttributes<HTMLAudioElement>>;
+interface CarouselProps extends React.HTMLAttributes<HTMLDivElement> {
+    items: React.ReactNode[];
+    autoPlay?: boolean;
+    autoPlayInterval?: number;
+    showDots?: boolean;
+    showArrows?: boolean;
+    loop?: boolean;
+    slidesPerView?: number;
+}
+declare const Carousel: React.ForwardRefExoticComponent<CarouselProps & React.RefAttributes<HTMLDivElement>>;
+interface GalleryImage {
+    src: string;
+    alt?: string;
+    caption?: string;
+    width?: number;
+    height?: number;
+}
+interface GalleryProps extends React.HTMLAttributes<HTMLDivElement> {
+    images: GalleryImage[];
+    columns?: 2 | 3 | 4 | 5;
+    gap?: number;
+    onImageClick?: (image: GalleryImage, index: number) => void;
+    rounded?: "none" | "sm" | "md" | "lg";
+}
+declare const Gallery: React.ForwardRefExoticComponent<GalleryProps & React.RefAttributes<HTMLDivElement>>;
+
+type Theme$1 = "light" | "dark" | "system";
+interface ThemeSwitcherProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "color" | "onChange"> {
+    value?: Theme$1;
+    onChange?: (theme: Theme$1) => void;
+    variant?: "icon" | "toggle" | "select";
+}
+declare const ThemeSwitcher: React.ForwardRefExoticComponent<ThemeSwitcherProps & React.RefAttributes<HTMLDivElement>>;
+interface CopyButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    text: string;
+    timeout?: number;
+    onCopied?: () => void;
+    size?: "sm" | "md" | "lg";
+    variant?: "icon" | "button";
+    label?: string;
+}
+declare const CopyButton: React.ForwardRefExoticComponent<CopyButtonProps & React.RefAttributes<HTMLButtonElement>>;
+interface KeyboardShortcutProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "color" | "size"> {
+    keys: string[];
+    separator?: string;
+    size?: "sm" | "md" | "lg";
+}
+declare const KeyboardShortcut: React.ForwardRefExoticComponent<KeyboardShortcutProps & React.RefAttributes<HTMLSpanElement>>;
+interface ResizablePanelProps extends React.HTMLAttributes<HTMLDivElement> {
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    direction?: "horizontal" | "vertical";
+    onResize?: (size: number) => void;
+}
+declare const ResizablePanel: React.ForwardRefExoticComponent<ResizablePanelProps & React.RefAttributes<HTMLDivElement>>;
+interface DragDropAreaProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onDrop" | "onDragOver"> {
+    onDrop?: (items: DataTransfer) => void;
+    onDragOver?: (e: React.DragEvent) => void;
+    accept?: string[];
+    disabled?: boolean;
+    active?: boolean;
+    label?: React.ReactNode;
+    icon?: React.ReactNode;
+    hint?: React.ReactNode;
+}
+declare const DragDropArea: React.ForwardRefExoticComponent<DragDropAreaProps & React.RefAttributes<HTMLDivElement>>;
+
+interface UseDisclosureOptions {
+    defaultOpen?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+}
+/**
+ * Manages open/close state for modals, drawers, popovers — anything
+ * that needs to toggle. Returns stable callbacks so child components
+ * don't re-render on every parent render.
+ */
+declare function useDisclosure(options?: UseDisclosureOptions): {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    onOpenChange: React.Dispatch<React.SetStateAction<boolean>>;
+};
+/**
+ * Subscribes to a CSS media query and returns whether it currently matches.
+ * SSR-safe — returns false on the server.
+ */
+declare function useMediaQuery(query: string): boolean;
+declare const breakpoints: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+};
+/**
+ * Returns true when the viewport is at or above the given Tailwind breakpoint.
+ *
+ * @example
+ * const isDesktop = useBreakpoint("lg");
+ */
+declare function useBreakpoint(bp: keyof typeof breakpoints): boolean;
+interface UseClipboardOptions {
+    timeout?: number;
+}
+/**
+ * Copies text to the clipboard and briefly flips `copied` to true.
+ * Falls back to execCommand for older browsers (looking at you, Safari).
+ *
+ * @example
+ * const { copy, copied } = useClipboard();
+ * <button onClick={() => copy(code)}>{copied ? "Copied!" : "Copy"}</button>
+ */
+declare function useClipboard(options?: UseClipboardOptions): {
+    copy: (text: string) => Promise<void>;
+    copied: boolean;
+};
+/**
+ * useState that persists to localStorage. Reads the initial value
+ * from storage on mount and syncs back on every set call.
+ * Safe to use with SSR — reads from storage only inside useEffect timing.
+ */
+declare function useLocalStorage<T>(key: string, defaultValue: T): [T, (value: T | ((prev: T) => T)) => void];
+type AtlasTheme = "light" | "dark" | "system";
+/**
+ * Read and set the current AtlasUI theme.
+ * Persists the selection to localStorage under "atlas-theme".
+ * Applies the "dark" class to <html> so Tailwind's dark: utilities kick in.
+ *
+ * @example
+ * const { theme, setTheme } = useTheme();
+ * <button onClick={() => setTheme("dark")}>Go dark</button>
+ */
+declare function useTheme(): {
+    theme: AtlasTheme;
+    resolvedTheme: "dark" | "light";
+    setTheme: (t: AtlasTheme) => void;
+};
+/**
+ * Delays updating the returned value until `delay` ms have passed
+ * without the input changing. Classic use case: search inputs.
+ */
+declare function useDebounce<T>(value: T, delay: number): T;
+/**
+ * Fires the handler when a click happens outside of the ref'd element.
+ * Used heavily inside AtlasUI popovers, dropdowns, and comboboxes.
+ */
+declare function useOnClickOutside<T extends HTMLElement>(ref: React.RefObject<T>, handler: (event: MouseEvent | TouchEvent) => void): void;
+/**
+ * Attaches a keydown listener to window for the given key.
+ * Supports modifier checks (Ctrl, Meta, Shift).
+ * Pass `enabled: false` to temporarily disable without removing the hook call.
+ *
+ * @example
+ * useKeydown("k", openCommandPalette, { metaKey: true });
+ */
+declare function useKeydown(key: string, handler: (event: KeyboardEvent) => void, options?: {
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    enabled?: boolean;
+}): void;
+/**
+ * Returns true after the component has mounted on the client.
+ * Use this to guard any DOM-dependent code in SSR environments
+ * (Next.js, Remix, etc.) without suppressHydrationWarning hacks.
+ */
+declare function useMounted(): boolean;
+
+type ToastVariant = "default" | "success" | "warning" | "danger" | "info";
+interface ToastData {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    variant?: ToastVariant;
+    duration?: number;
+    action?: React.ReactNode;
+}
+type ToastInput = Omit<ToastData, "id">;
+interface ToastContextValue {
+    toasts: ToastData[];
+    toast: (input: ToastInput) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+}
+declare function ToastContextProvider({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useToast(): ToastContextValue;
+
+type Size = "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
+type ResponsiveSize = Size | Partial<Record<"base" | "sm" | "md" | "lg" | "xl", Size>>;
+type ColorScheme = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral" | "ghost";
+type Variant = "solid" | "outline" | "ghost" | "soft" | "link";
+type Placement = "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
+type Side = "top" | "right" | "bottom" | "left";
+interface AtlasBaseProps {
+    /** Additional CSS class names */
+    className?: string;
+    /** Inline style overrides */
+    style?: React__default.CSSProperties;
+    /** Data attributes passthrough */
+    [key: `data-${string}`]: unknown;
+}
+interface AtlasAriaProps {
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-hidden"?: boolean;
+    id?: string;
+}
+type AsChildProps<T extends React__default.ElementType = React__default.ElementType> = {
+    asChild?: boolean;
+    as?: T;
+};
+type Orientation = "horizontal" | "vertical";
+type Status = "idle" | "loading" | "success" | "error" | "warning";
+type Theme = "light" | "dark" | "system";
+
+/**
+ * Merges Tailwind classes without conflicts.
+ * Wrapper around clsx + tailwind-merge — use this everywhere in AtlasUI
+ * instead of raw string concatenation.
+ *
+ * @example
+ * cn("px-4 py-2", isLarge && "px-8", className)
+ */
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Chains two event handlers so both fire, but respects defaultPrevented
+ * on the original handler before calling ours.
+ */
+declare function composeEventHandlers<E>(originalEventHandler?: (event: E) => void, ourEventHandler?: (event: E) => void, { checkForDefaultPrevented }?: {
+    checkForDefaultPrevented?: boolean | undefined;
+}): (event: E) => void;
+declare function generateId(prefix?: string): string;
+/** True only in browser environments. Guards SSR code paths. */
+declare const isBrowser: boolean;
+/** A do-nothing function. Handy as a default prop value. */
+declare const noop: () => undefined;
+/** Narrows out null and undefined from a value. */
+declare function isDefined<T>(value: T | undefined | null): value is T;
+
+/**
+ * AtlasUI Tailwind plugin.
+ *
+ * Maps the CSS custom properties in atlas.css to Tailwind utilities.
+ * Add to your tailwind.config.ts:
+ *
+ *   import { atlasPlugin } from "atlasui-lib/tailwind";
+ *   plugins: [atlasPlugin],
+ *
+ * Or use atlasPreset which also sets darkMode: ["class"]:
+ *
+ *   import { atlasPreset } from "atlasui-lib/tailwind";
+ *   presets: [atlasPreset],
+ */
+declare const atlasPlugin: {
+    handler: tailwindcss_types_config.PluginCreator;
+    config?: Partial<tailwindcss_types_config.Config>;
+};
+/** Full preset — includes the plugin + darkMode: ["class"]. Recommended for new projects. */
+declare const atlasPreset: Partial<Config>;
+
+export { Alert, AlertDescription, type AlertProps, AlertTitle, type AsChildProps, AspectRatio, type AtlasAriaProps, type AtlasBaseProps, type AtlasTheme, AudioPlayer, type AudioPlayerProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, Badge, type BadgeProps, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, type ButtonProps, Calendar, type CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, Carousel, type CarouselProps, Center, type CenterProps, Chart, type ChartProps, Checkbox, type CheckboxProps, Chip, type ChipProps, CircularProgress, type CircularProgressProps, CodeBlock, type CodeBlockProps, ColorPicker, type ColorPickerProps, type ColorScheme, Combobox, type ComboboxOption, type ComboboxProps, CommandDialog, type CommandDialogProps, CommandGroup, CommandItem, CommandSeparator, Container, type ContainerProps, ContextMenu, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuRadioGroup, ContextMenuSeparator, ContextMenuSub, ContextMenuTrigger, CopyButton, type CopyButtonProps, DataTable, type DataTableColumn, type DataTableProps, DatePicker, type DatePickerProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Divider, type DividerProps, DragDropArea, type DragDropAreaProps, Drawer, type DrawerProps, DropdownMenu, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuTrigger, EmptyState, type EmptyStateProps, FileUpload, type FileUploadProps, Flex, type FlexProps, FormError, type FormErrorProps, FormField, type FormFieldProps, FormLabel, type FormLabelProps, Gallery, type GalleryImage, type GalleryProps, Grid, type GridProps, HoverCard, HoverCardContent, HoverCardTrigger, IconButton, type IconButtonProps, Image, type ImageProps, ImageViewer, Input, type InputProps, KeyboardShortcut, type KeyboardShortcutProps, Lightbox, type LightboxProps, Link, type LinkProps, List, ListItem, type ListItemProps, type ListProps, LoadingSpinner, type LoadingSpinnerProps, Masonry, type MasonryProps, Menu, MenuItem, type MenuItemProps, Modal, type ModalProps, MultiSelect, type MultiSelectProps, Navbar, type NavbarProps, Notification, type NotificationProps, OTPInput, type OTPInputProps, type Orientation, Pagination, type PaginationProps, PasswordInput, type PasswordInputProps, type Placement, Popover, PopoverContent, PopoverTrigger, Progress, type ProgressProps, RadioGroup, type RadioGroupProps, type RadioOption, RangeSlider, ResizablePanel, type ResizablePanelProps, type ResponsiveSize, ScrollArea, SearchInput, type SearchInputProps, Section, type SectionProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue, Sheet, type Side, Sidebar, type SidebarProps, type Size, Skeleton, type SkeletonProps, Slider, Snackbar, type SnackbarProps, Spacer, type SpacerProps, Stack, type StackProps, Statistic, type StatisticProps, type Status, StatusIndicator, type StatusIndicatorProps, Stepper, type StepperProps, type StepperStep, Switch, type SwitchProps, Table, TableBody, TableCaption, TableCell, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Tag, type TagProps, TextArea, type TextAreaProps, type Theme, ThemeSwitcher, type ThemeSwitcherProps, TimePicker, type TimePickerProps, Timeline, type TimelineEvent, type TimelineProps, Toast, ToastAction, ToastClose, ToastContextProvider, type ToastData, ToastDescription, type ToastInput, ToastProvider, ToastTitle, type ToastVariant, ToastViewport, Tooltip, TooltipContent, type TooltipProps, TooltipProvider, TooltipRoot, TooltipTrigger, type UseClipboardOptions, type UseDisclosureOptions, type Variant, VideoPlayer, type VideoPlayerProps, atlasPlugin, atlasPreset, badgeVariants, buttonVariants, cn, composeEventHandlers, generateId, iconButtonVariants, inputVariants, isBrowser, isDefined, noop, useBreakpoint, useClipboard, useDebounce, useDisclosure, useKeydown, useLocalStorage, useMediaQuery, useMounted, useOnClickOutside, useTheme, useToast };