ui_zenkit 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,4776 @@
+import * as react from 'react';
+import react__default, { CSSProperties, ReactNode, ButtonHTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes, SelectHTMLAttributes, FormHTMLAttributes, HTMLAttributes, ElementType, ReactElement, ImgHTMLAttributes, ThHTMLAttributes, TdHTMLAttributes, SVGAttributes, AnchorHTMLAttributes, Component, ErrorInfo } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ClassValue } from 'clsx';
+
+type Size = 'sm' | 'md' | 'lg';
+type Variant = 'solid' | 'outline' | 'ghost' | 'link';
+type ColorScheme$1 = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'light' | 'dark';
+interface BaseProps {
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+type PolymorphicRef<T extends React.ElementType> = React.ComponentPropsWithRef<T>['ref'];
+type PolymorphicComponentProps<T extends React.ElementType, Props = object> = Props & Omit<React.ComponentPropsWithoutRef<T>, keyof Props> & {
+    as?: T;
+};
+type PolymorphicComponentPropsWithRef<T extends React.ElementType, Props = object> = PolymorphicComponentProps<T, Props> & {
+    ref?: PolymorphicRef<T>;
+};
+
+type ButtonVariant = 'solid' | 'outline' | 'ghost' | 'link' | 'soft';
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    colorScheme?: ColorScheme$1;
+    size?: Size;
+    fullWidth?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    iconOnly?: boolean;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix'> {
+    /** Input size variant */
+    size?: Size;
+    /** Error state */
+    error?: boolean;
+    /** Prefix element (icon or text) */
+    prefix?: ReactNode;
+    /** Suffix element (icon or text) */
+    suffix?: ReactNode;
+    /** Show clear button */
+    allowClear?: boolean;
+    /** Callback when clear button is clicked */
+    onClear?: () => void;
+    /** Full width input */
+    fullWidth?: boolean;
+    /** Wrapper className */
+    wrapperClassName?: string;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'size'> {
+    /** Textarea size variant */
+    size?: Size;
+    /** Error state */
+    error?: boolean;
+    /** Auto grow based on content */
+    autoGrow?: boolean;
+    /** Minimum rows for auto grow */
+    minRows?: number;
+    /** Maximum rows for auto grow */
+    maxRows?: number;
+    /** Show character counter */
+    showCount?: boolean;
+    /** Full width textarea */
+    fullWidth?: boolean;
+}
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'> {
+    /** Checkbox label */
+    label?: ReactNode;
+    /** Checkbox size */
+    size?: Size;
+    /** Color scheme */
+    colorScheme?: ColorScheme$1;
+    /** Indeterminate state */
+    indeterminate?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Label position */
+    labelPosition?: 'left' | 'right';
+}
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface RadioGroupProps {
+    children: ReactNode;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    size?: Size;
+    colorScheme?: ColorScheme$1;
+    disabled?: boolean;
+    direction?: 'horizontal' | 'vertical';
+    className?: string;
+}
+declare const RadioGroup: {
+    ({ children, name, value, onChange, size, colorScheme, disabled, direction, className, }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'> {
+    /** Radio label */
+    label?: ReactNode;
+    /** Radio size */
+    size?: Size;
+    /** Color scheme */
+    colorScheme?: ColorScheme$1;
+    /** Error state */
+    error?: boolean;
+    /** Label position */
+    labelPosition?: 'left' | 'right';
+}
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SelectOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectOptionGroup {
+    label: string;
+    options: SelectOption[];
+}
+interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'size' | 'prefix'> {
+    /** Select options */
+    options?: (SelectOption | SelectOptionGroup)[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Select size */
+    size?: Size;
+    /** Error state */
+    error?: boolean;
+    /** Full width */
+    fullWidth?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Prefix element */
+    prefixIcon?: ReactNode;
+}
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
+
+interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'> {
+    /** Switch label */
+    label?: ReactNode;
+    /** Switch size */
+    size?: Size;
+    /** Color scheme */
+    colorScheme?: ColorScheme$1;
+    /** Loading state */
+    loading?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Label position */
+    labelPosition?: 'left' | 'right';
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+
+interface FormContextValue {
+    layout?: 'vertical' | 'horizontal' | 'inline';
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    requiredMark?: boolean | 'optional';
+}
+declare const useFormContext: () => FormContextValue;
+interface FormProps extends FormHTMLAttributes<HTMLFormElement> {
+    /** Form layout */
+    layout?: 'vertical' | 'horizontal' | 'inline';
+    /** Form size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disable all form fields */
+    disabled?: boolean;
+    /** Show required mark */
+    requiredMark?: boolean | 'optional';
+}
+declare const Form: react.ForwardRefExoticComponent<FormProps & react.RefAttributes<HTMLFormElement>>;
+interface FormItemProps {
+    /** Label text */
+    label?: ReactNode;
+    /** Helper text */
+    helperText?: ReactNode;
+    /** Error message */
+    error?: ReactNode;
+    /** Required field */
+    required?: boolean;
+    /** HTML for attribute */
+    htmlFor?: string;
+    /** Children elements */
+    children?: ReactNode;
+    /** Additional class name */
+    className?: string;
+}
+declare const FormItem: {
+    ({ label, helperText, error, required, htmlFor, children, className, }: FormItemProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type TypographyVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'body1' | 'body2' | 'caption' | 'overline';
+interface TypographyProps extends HTMLAttributes<HTMLElement> {
+    /** Typography variant */
+    variant?: TypographyVariant;
+    /** Custom element type */
+    as?: ElementType;
+    /** Color */
+    color?: ColorScheme$1 | 'muted' | 'inherit';
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right' | 'justify';
+    /** Truncate text */
+    truncate?: boolean;
+    /** Number of lines before truncation */
+    lineClamp?: number;
+    /** Font weight */
+    weight?: 'light' | 'normal' | 'medium' | 'semibold' | 'bold';
+    /** Italic text */
+    italic?: boolean;
+    /** Underline text */
+    underline?: boolean;
+    /** Strikethrough text */
+    strikethrough?: boolean;
+    /** Disable margin */
+    noMargin?: boolean;
+}
+declare const Typography: react.ForwardRefExoticComponent<TypographyProps & react.RefAttributes<HTMLElement>>;
+declare const Heading: react.ForwardRefExoticComponent<Omit<TypographyProps, "variant"> & {
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+} & react.RefAttributes<HTMLHeadingElement>>;
+declare const Text: react.ForwardRefExoticComponent<Omit<TypographyProps, "variant"> & {
+    size?: "sm" | "md";
+} & react.RefAttributes<HTMLParagraphElement>>;
+
+type ColSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto';
+type Gap$1 = 0 | 1 | 2 | 3 | 4 | 5;
+interface GridProps extends HTMLAttributes<HTMLDivElement> {
+    /** Number of columns */
+    columns?: number;
+    /** Gap between items */
+    gap?: Gap$1;
+    /** Row gap */
+    rowGap?: Gap$1;
+    /** Column gap */
+    columnGap?: Gap$1;
+    /** Align items */
+    alignItems?: CSSProperties['alignItems'];
+    /** Justify content */
+    justifyContent?: CSSProperties['justifyContent'];
+}
+interface ColProps extends HTMLAttributes<HTMLDivElement> {
+    /** Column span */
+    span?: ColSpan;
+    /** Offset */
+    offset?: number;
+    /** Small breakpoint span */
+    sm?: ColSpan;
+    /** Medium breakpoint span */
+    md?: ColSpan;
+    /** Large breakpoint span */
+    lg?: ColSpan;
+    /** Extra large breakpoint span */
+    xl?: ColSpan;
+}
+declare const Grid: react.ForwardRefExoticComponent<GridProps & react.RefAttributes<HTMLDivElement>>;
+declare const Col: react.ForwardRefExoticComponent<ColProps & react.RefAttributes<HTMLDivElement>>;
+
+type Gap = 0 | 1 | 2 | 3 | 4 | 5;
+interface FlexProps extends HTMLAttributes<HTMLDivElement> {
+    /** Flex direction */
+    direction?: CSSProperties['flexDirection'];
+    /** Align items */
+    align?: CSSProperties['alignItems'];
+    /** Justify content */
+    justify?: CSSProperties['justifyContent'];
+    /** Flex wrap */
+    wrap?: CSSProperties['flexWrap'];
+    /** Gap between items */
+    gap?: Gap;
+    /** Display inline-flex */
+    inline?: boolean;
+}
+declare const Flex: react.ForwardRefExoticComponent<FlexProps & react.RefAttributes<HTMLDivElement>>;
+
+type SpaceSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+interface SpaceProps extends HTMLAttributes<HTMLDivElement> {
+    /** Direction of space */
+    direction?: 'horizontal' | 'vertical';
+    /** Size of spacing */
+    size?: SpaceSize;
+    /** Wrap items */
+    wrap?: boolean;
+    /** Alignment */
+    align?: 'start' | 'end' | 'center' | 'baseline';
+    /** Divider between items */
+    divider?: React.ReactNode;
+}
+declare const Space: react.ForwardRefExoticComponent<SpaceProps & react.RefAttributes<HTMLDivElement>>;
+
+type ContainerSize = 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'fluid';
+interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Container max-width size */
+    size?: ContainerSize;
+    /** Center the container */
+    centered?: boolean;
+    /** Add padding */
+    padding?: boolean;
+}
+declare const Container: react.ForwardRefExoticComponent<ContainerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    /** Card variant */
+    variant?: 'default' | 'outlined' | 'filled' | 'elevated';
+    /** Hover effect */
+    hoverable?: boolean;
+    /** Clickable card */
+    clickable?: boolean;
+    /** Card size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Full width */
+    fullWidth?: boolean;
+}
+interface CardHeaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Header title */
+    title?: ReactNode;
+    /** Header subtitle */
+    subtitle?: ReactNode;
+    /** Extra content (right side) */
+    extra?: ReactNode;
+}
+interface CardBodyProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface CardFooterProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: react.ForwardRefExoticComponent<CardHeaderProps & react.RefAttributes<HTMLDivElement>>;
+declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: react.ForwardRefExoticComponent<CardFooterProps & react.RefAttributes<HTMLDivElement>>;
+
+type AlertVariant = 'filled' | 'outlined' | 'soft';
+type AlertStatus = 'info' | 'success' | 'warning' | 'danger';
+interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Alert status/type */
+    status?: AlertStatus;
+    /** Alert variant */
+    variant?: AlertVariant;
+    /** Alert title */
+    title?: ReactNode;
+    /** Alert icon */
+    icon?: ReactNode;
+    /** Show close button */
+    closable?: boolean;
+    /** Close callback */
+    onClose?: () => void;
+    /** Custom close button */
+    closeButton?: ReactNode;
+    /** Action buttons */
+    action?: ReactNode;
+}
+declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;
+
+type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Whether modal is open */
+    isOpen: boolean;
+    /** Close callback */
+    onClose: () => void;
+    /** Modal title */
+    title?: ReactNode;
+    /** Modal size */
+    size?: ModalSize;
+    /** Show close button */
+    showCloseButton?: boolean;
+    /** Close on overlay click */
+    closeOnOverlayClick?: boolean;
+    /** Close on escape key */
+    closeOnEscape?: boolean;
+    /** Center modal vertically */
+    centered?: boolean;
+    /** Scrollable body */
+    scrollable?: boolean;
+    /** Footer content */
+    footer?: ReactNode;
+    /** Prevent body scroll when open */
+    lockScroll?: boolean;
+}
+declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDivElement>>;
+interface ModalHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    onClose?: () => void;
+    showCloseButton?: boolean;
+}
+declare const ModalHeader: react.ForwardRefExoticComponent<ModalHeaderProps & react.RefAttributes<HTMLDivElement>>;
+declare const ModalBody: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const ModalFooter: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+type Theme = 'light' | 'dark' | 'system';
+type ColorScheme = 'light' | 'dark';
+interface ZenKitContextValue {
+    theme: Theme;
+    colorScheme: ColorScheme;
+    setTheme: (theme: Theme) => void;
+    toggleTheme: () => void;
+}
+interface ZenKitProviderProps {
+    children: ReactNode;
+    /** Default theme */
+    defaultTheme?: Theme;
+    /** Storage key for persisting theme */
+    storageKey?: string;
+    /** Attribute to set on document element */
+    attribute?: 'class' | 'data-theme';
+}
+declare const ZenKitProvider: {
+    ({ children, defaultTheme, storageKey, attribute, }: ZenKitProviderProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const useTheme: () => ZenKitContextValue;
+declare const useThemeOptional: () => ZenKitContextValue | undefined;
+
+type TabsVariant = 'default' | 'pills' | 'underline';
+interface TabsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Default active tab key */
+    defaultActiveKey?: string;
+    /** Controlled active tab key */
+    activeKey?: string;
+    /** Tab change callback */
+    onChange?: (key: string) => void;
+    /** Tabs variant */
+    variant?: TabsVariant;
+    /** Full width tabs */
+    fullWidth?: boolean;
+}
+interface TabListProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface TabProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Tab key identifier */
+    tabKey: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Tab icon */
+    icon?: ReactNode;
+}
+interface TabPanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Panel key matching tab key */
+    tabKey: string;
+}
+declare const Tabs: react.ForwardRefExoticComponent<TabsProps & react.RefAttributes<HTMLDivElement>>;
+declare const TabList: react.ForwardRefExoticComponent<TabListProps & react.RefAttributes<HTMLDivElement>>;
+declare const Tab: react.ForwardRefExoticComponent<TabProps & react.RefAttributes<HTMLButtonElement>>;
+declare const TabPanel: react.ForwardRefExoticComponent<TabPanelProps & react.RefAttributes<HTMLDivElement>>;
+
+interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'> {
+    /** Current page */
+    current?: number;
+    /** Total number of pages */
+    total: number;
+    /** Items per page */
+    pageSize?: number;
+    /** Page change callback */
+    onChange?: (page: number) => void;
+    /** Show size changer */
+    showSizeChanger?: boolean;
+    /** Size change callback */
+    onSizeChange?: (size: number) => void;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Show quick jumper */
+    showQuickJumper?: boolean;
+    /** Pagination size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Show total count */
+    showTotal?: boolean;
+}
+declare const Pagination: react.ForwardRefExoticComponent<PaginationProps & react.RefAttributes<HTMLElement>>;
+
+interface BreadcrumbProps extends HTMLAttributes<HTMLElement> {
+    /** Custom separator */
+    separator?: ReactNode;
+}
+interface BreadcrumbItemProps extends HTMLAttributes<HTMLLIElement> {
+    /** Link href */
+    href?: string;
+    /** Active/current item */
+    active?: boolean;
+    /** Custom icon */
+    icon?: ReactNode;
+}
+declare const Breadcrumb: react.ForwardRefExoticComponent<BreadcrumbProps & react.RefAttributes<HTMLElement>>;
+declare const BreadcrumbItem: react.ForwardRefExoticComponent<BreadcrumbItemProps & react.RefAttributes<HTMLLIElement>>;
+
+type MenuMode = 'vertical' | 'horizontal' | 'inline';
+interface MenuProps extends Omit<HTMLAttributes<HTMLElement>, 'onSelect'> {
+    /** Menu mode */
+    mode?: MenuMode;
+    /** Default active menu item key */
+    defaultActiveKey?: string;
+    /** Controlled active menu item key */
+    activeKey?: string;
+    /** Default open submenu keys */
+    defaultOpenKeys?: string[];
+    /** Controlled open submenu keys */
+    openKeys?: string[];
+    /** Active key change callback */
+    onSelect?: (key: string) => void;
+    /** Open keys change callback */
+    onOpenChange?: (keys: string[]) => void;
+    /** Collapsed state (for inline mode) */
+    collapsed?: boolean;
+}
+interface MenuItemProps extends HTMLAttributes<HTMLLIElement> {
+    /** Menu item key */
+    itemKey: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Item icon */
+    icon?: ReactNode;
+}
+interface SubMenuProps extends Omit<HTMLAttributes<HTMLLIElement>, 'title'> {
+    /** Submenu key */
+    subKey: string;
+    /** Submenu title */
+    title: ReactNode;
+    /** Submenu icon */
+    icon?: ReactNode;
+    /** Disabled state */
+    disabled?: boolean;
+}
+interface MenuGroupProps extends Omit<HTMLAttributes<HTMLLIElement>, 'title'> {
+    /** Group title */
+    title: ReactNode;
+}
+interface MenuDividerProps extends HTMLAttributes<HTMLLIElement> {
+}
+declare const Menu: react.ForwardRefExoticComponent<MenuProps & react.RefAttributes<HTMLElement>>;
+declare const MenuItem: react.ForwardRefExoticComponent<MenuItemProps & react.RefAttributes<HTMLLIElement>>;
+declare const SubMenu: react.ForwardRefExoticComponent<SubMenuProps & react.RefAttributes<HTMLLIElement>>;
+declare const MenuGroup: react.ForwardRefExoticComponent<MenuGroupProps & react.RefAttributes<HTMLLIElement>>;
+declare const MenuDivider: react.ForwardRefExoticComponent<MenuDividerProps & react.RefAttributes<HTMLLIElement>>;
+
+type StepsDirection = 'horizontal' | 'vertical';
+type StepStatus = 'wait' | 'process' | 'finish' | 'error';
+interface StepsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Current step index (0-based) */
+    current?: number;
+    /** Steps direction */
+    direction?: StepsDirection;
+    /** Size variant */
+    size?: 'sm' | 'md';
+    /** Clickable steps */
+    clickable?: boolean;
+    /** Step click callback */
+    onChange?: (step: number) => void;
+}
+interface StepProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Step title */
+    title: ReactNode;
+    /** Step description */
+    description?: ReactNode;
+    /** Step icon */
+    icon?: ReactNode;
+    /** Step status override */
+    status?: StepStatus;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const Steps: react.ForwardRefExoticComponent<StepsProps & react.RefAttributes<HTMLDivElement>>;
+declare const Step: react.ForwardRefExoticComponent<StepProps & react.RefAttributes<HTMLDivElement>>;
+
+type DropdownPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+interface DropdownProps extends HTMLAttributes<HTMLDivElement> {
+    /** Controlled open state */
+    open?: boolean;
+    /** Open state change callback */
+    onOpenChange?: (open: boolean) => void;
+    /** Placement of dropdown menu */
+    placement?: DropdownPlacement;
+}
+interface DropdownTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** As child - renders children as trigger */
+    asChild?: boolean;
+}
+interface DropdownMenuProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface DropdownItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Disabled state */
+    disabled?: boolean;
+    /** Danger/destructive action */
+    danger?: boolean;
+    /** Icon */
+    icon?: ReactNode;
+    /** Click handler */
+    onSelect?: () => void;
+}
+interface DropdownDividerProps extends HTMLAttributes<HTMLHRElement> {
+}
+interface DropdownHeaderProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const Dropdown: react.ForwardRefExoticComponent<DropdownProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownTrigger: react.ForwardRefExoticComponent<DropdownTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenu: react.ForwardRefExoticComponent<DropdownMenuProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownItem: react.ForwardRefExoticComponent<DropdownItemProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownDivider: react.ForwardRefExoticComponent<DropdownDividerProps & react.RefAttributes<HTMLHRElement>>;
+declare const DropdownHeader: react.ForwardRefExoticComponent<DropdownHeaderProps & react.RefAttributes<HTMLDivElement>>;
+
+type TooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
+interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, 'content'> {
+    /** Tooltip content */
+    content: React.ReactNode;
+    /** Tooltip placement */
+    placement?: TooltipPlacement;
+    /** Delay before showing (ms) */
+    delay?: number;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Arrow visibility */
+    arrow?: boolean;
+    /** Trigger element */
+    children: ReactElement;
+}
+declare const Tooltip: react.ForwardRefExoticComponent<TooltipProps & react.RefAttributes<HTMLDivElement>>;
+
+type PopoverPlacement = 'top' | 'right' | 'bottom' | 'left';
+type PopoverTrigger = 'click' | 'hover';
+interface PopoverProps extends Omit<HTMLAttributes<HTMLDivElement>, 'content' | 'title'> {
+    /** Popover title */
+    title?: ReactNode;
+    /** Popover content */
+    content: ReactNode;
+    /** Popover placement */
+    placement?: PopoverPlacement;
+    /** Trigger mode */
+    trigger?: PopoverTrigger;
+    /** Controlled open state */
+    open?: boolean;
+    /** Open state change callback */
+    onOpenChange?: (open: boolean) => void;
+    /** Arrow visibility */
+    arrow?: boolean;
+    /** Trigger element */
+    children: ReactElement;
+}
+declare const Popover: react.ForwardRefExoticComponent<PopoverProps & react.RefAttributes<HTMLDivElement>>;
+
+type DrawerPlacement = 'left' | 'right' | 'top' | 'bottom';
+type DrawerSize = 'sm' | 'md' | 'lg' | 'full';
+interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Drawer open state */
+    open: boolean;
+    /** Close callback */
+    onClose: () => void;
+    /** Drawer title */
+    title?: ReactNode;
+    /** Drawer placement */
+    placement?: DrawerPlacement;
+    /** Drawer size */
+    size?: DrawerSize;
+    /** Show close button */
+    closable?: boolean;
+    /** Show overlay/mask */
+    mask?: boolean;
+    /** Close on mask click */
+    maskClosable?: boolean;
+    /** Close on escape key */
+    closeOnEsc?: boolean;
+    /** Footer content */
+    footer?: ReactNode;
+    /** Custom width (overrides size) */
+    width?: number | string;
+    /** Custom height (overrides size for top/bottom) */
+    height?: number | string;
+}
+declare const Drawer: react.ForwardRefExoticComponent<DrawerProps & react.RefAttributes<HTMLDivElement>>;
+
+type ProgressStatus = 'default' | 'success' | 'warning' | 'danger';
+interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    /** Progress value (0-100) */
+    value?: number;
+    /** Maximum value */
+    max?: number;
+    /** Show percentage label */
+    showLabel?: boolean;
+    /** Progress size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Striped style */
+    striped?: boolean;
+    /** Animated stripes */
+    animated?: boolean;
+    /** Progress status/color */
+    status?: ProgressStatus;
+    /** Indeterminate loading state */
+    indeterminate?: boolean;
+}
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+
+type SpinnerSize = 'sm' | 'md' | 'lg';
+type SpinnerVariant = 'border' | 'grow';
+interface SpinnerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Spinner size */
+    size?: SpinnerSize;
+    /** Spinner variant */
+    variant?: SpinnerVariant;
+    /** Spinner color */
+    color?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'light' | 'dark';
+    /** Accessible label */
+    label?: string;
+}
+declare const Spinner: react.ForwardRefExoticComponent<SpinnerProps & react.RefAttributes<HTMLDivElement>>;
+
+type NotificationType = 'info' | 'success' | 'warning' | 'error';
+type NotificationPlacement = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
+interface NotificationProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Notification type */
+    type?: NotificationType;
+    /** Notification title */
+    title?: ReactNode;
+    /** Notification message */
+    message: ReactNode;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Show close button */
+    closable?: boolean;
+    /** Close callback */
+    onClose?: () => void;
+    /** Auto close duration in ms (0 to disable) */
+    duration?: number;
+    /** Action buttons */
+    action?: ReactNode;
+}
+interface NotificationContainerProps {
+    placement?: NotificationPlacement;
+    notifications: NotificationItem[];
+    onClose: (id: string) => void;
+}
+interface NotificationItem {
+    id: string;
+    props: NotificationProps;
+}
+declare const Notification: react.ForwardRefExoticComponent<NotificationProps & react.RefAttributes<HTMLDivElement>>;
+declare const NotificationContainer: react.ForwardRefExoticComponent<NotificationContainerProps & react.RefAttributes<HTMLDivElement>>;
+
+type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type AvatarShape = 'circle' | 'square' | 'rounded';
+interface AvatarProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Image source */
+    src?: string;
+    /** Image alt text */
+    alt?: string;
+    /** Avatar size */
+    size?: AvatarSize;
+    /** Avatar shape */
+    shape?: AvatarShape;
+    /** Fallback text (initials) */
+    fallback?: string;
+    /** Custom image props */
+    imgProps?: ImgHTMLAttributes<HTMLImageElement>;
+}
+interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Maximum avatars to show */
+    max?: number;
+    /** Avatar size for group */
+    size?: AvatarSize;
+}
+declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLSpanElement>>;
+declare const AvatarGroup: react.ForwardRefExoticComponent<AvatarGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+type BadgeVariant = 'solid' | 'soft' | 'outline';
+type BadgeColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info';
+type BadgeSize = 'sm' | 'md' | 'lg';
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Badge variant */
+    variant?: BadgeVariant;
+    /** Badge color */
+    color?: BadgeColor;
+    /** Badge size */
+    size?: BadgeSize;
+    /** Pill shape */
+    pill?: boolean;
+    /** Dot indicator (no text) */
+    dot?: boolean;
+}
+declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLSpanElement>>;
+
+type TagVariant = 'solid' | 'soft' | 'outline';
+type TagColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'default';
+type TagSize = 'sm' | 'md' | 'lg';
+interface TagProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Tag variant */
+    variant?: TagVariant;
+    /** Tag color */
+    color?: TagColor;
+    /** Tag size */
+    size?: TagSize;
+    /** Closable tag */
+    closable?: boolean;
+    /** Close callback */
+    onClose?: () => void;
+    /** Left icon */
+    icon?: ReactNode;
+}
+declare const Tag: react.ForwardRefExoticComponent<TagProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface CollapseProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Default active panel keys */
+    defaultActiveKey?: string | string[];
+    /** Controlled active panel keys */
+    activeKey?: string | string[];
+    /** Active key change callback */
+    onChange?: (keys: string[]) => void;
+    /** Accordion mode (only one panel open) */
+    accordion?: boolean;
+    /** Bordered style */
+    bordered?: boolean;
+}
+interface CollapsePanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Panel unique key */
+    panelKey: string;
+    /** Panel header */
+    header: ReactNode;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Show arrow icon */
+    showArrow?: boolean;
+    /** Extra content in header */
+    extra?: ReactNode;
+}
+declare const Collapse: react.ForwardRefExoticComponent<CollapseProps & react.RefAttributes<HTMLDivElement>>;
+declare const CollapsePanel: react.ForwardRefExoticComponent<CollapsePanelProps & react.RefAttributes<HTMLDivElement>>;
+
+type DividerOrientation = 'horizontal' | 'vertical';
+type DividerVariant = 'solid' | 'dashed' | 'dotted';
+interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Divider orientation */
+    orientation?: DividerOrientation;
+    /** Divider style variant */
+    variant?: DividerVariant;
+    /** Text label position */
+    labelPosition?: 'left' | 'center' | 'right';
+    /** Text content */
+    children?: ReactNode;
+}
+declare const Divider: react.ForwardRefExoticComponent<DividerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    /** Slider value */
+    value?: number;
+    /** Default value */
+    defaultValue?: number;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Show marks */
+    showMarks?: boolean;
+    /** Show tooltip */
+    showTooltip?: boolean;
+    /** Slider size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Slider color */
+    color?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning';
+}
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+
+type TableSize = 'sm' | 'md' | 'lg';
+type TableVariant = 'default' | 'striped' | 'bordered';
+interface TableProps extends HTMLAttributes<HTMLTableElement> {
+    /** Table size */
+    size?: TableSize;
+    /** Table variant */
+    variant?: TableVariant;
+    /** Hoverable rows */
+    hoverable?: boolean;
+    /** Fixed header */
+    stickyHeader?: boolean;
+    /** Responsive wrapper */
+    responsive?: boolean;
+    /** Caption text */
+    caption?: ReactNode;
+    /** Caption placement */
+    captionSide?: 'top' | 'bottom';
+}
+interface TableHeadProps extends HTMLAttributes<HTMLTableSectionElement> {
+}
+interface TableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
+}
+interface TableFootProps extends HTMLAttributes<HTMLTableSectionElement> {
+}
+interface TableRowProps extends HTMLAttributes<HTMLTableRowElement> {
+    /** Selected state */
+    selected?: boolean;
+}
+interface TableHeaderProps extends ThHTMLAttributes<HTMLTableCellElement> {
+    /** Sortable column */
+    sortable?: boolean;
+    /** Sort direction */
+    sortDirection?: 'asc' | 'desc' | null;
+    /** Sort click handler */
+    onSort?: () => void;
+}
+interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
+}
+declare const Table: react.ForwardRefExoticComponent<TableProps & react.RefAttributes<HTMLTableElement>>;
+declare const TableHead: react.ForwardRefExoticComponent<TableHeadProps & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: react.ForwardRefExoticComponent<TableBodyProps & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFoot: react.ForwardRefExoticComponent<TableFootProps & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: react.ForwardRefExoticComponent<TableRowProps & react.RefAttributes<HTMLTableRowElement>>;
+declare const TableHeader: react.ForwardRefExoticComponent<TableHeaderProps & react.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: react.ForwardRefExoticComponent<TableCellProps & react.RefAttributes<HTMLTableCellElement>>;
+
+type ListSize = 'sm' | 'md' | 'lg';
+interface ListProps extends HTMLAttributes<HTMLDivElement> {
+    /** List size */
+    size?: ListSize;
+    /** Bordered list */
+    bordered?: boolean;
+    /** Split items with divider */
+    split?: boolean;
+    /** List header */
+    header?: ReactNode;
+    /** List footer */
+    footer?: ReactNode;
+    /** Loading state */
+    loading?: boolean;
+    /** Empty content when no items */
+    emptyText?: ReactNode;
+}
+interface ListItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Extra content (right side) */
+    extra?: ReactNode;
+    /** Actions (bottom right) */
+    actions?: ReactNode[];
+}
+interface ListItemMetaProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Avatar/image */
+    avatar?: ReactNode;
+    /** Title */
+    title?: ReactNode;
+    /** Description */
+    description?: ReactNode;
+}
+declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
+declare const ListItem: react.ForwardRefExoticComponent<ListItemProps & react.RefAttributes<HTMLDivElement>>;
+declare const ListItemMeta: react.ForwardRefExoticComponent<ListItemMetaProps & react.RefAttributes<HTMLDivElement>>;
+
+type DescriptionsLayout = 'horizontal' | 'vertical';
+type DescriptionsSize = 'sm' | 'md' | 'lg';
+interface DescriptionsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Title */
+    title?: ReactNode;
+    /** Extra content (top right) */
+    extra?: ReactNode;
+    /** Layout direction */
+    layout?: DescriptionsLayout;
+    /** Number of columns */
+    column?: number;
+    /** Bordered style */
+    bordered?: boolean;
+    /** Size */
+    size?: DescriptionsSize;
+    /** Colon after label */
+    colon?: boolean;
+}
+interface DescriptionsItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Item label */
+    label: ReactNode;
+    /** Span columns */
+    span?: number;
+}
+declare const Descriptions: react.ForwardRefExoticComponent<DescriptionsProps & react.RefAttributes<HTMLDivElement>>;
+declare const DescriptionsItem: react.ForwardRefExoticComponent<DescriptionsItemProps & react.RefAttributes<HTMLDivElement>>;
+
+type TimelineMode = 'left' | 'right' | 'alternate';
+interface TimelineProps extends HTMLAttributes<HTMLUListElement> {
+    /** Timeline mode */
+    mode?: TimelineMode;
+    /** Pending item at the end */
+    pending?: ReactNode;
+    /** Pending dot */
+    pendingDot?: ReactNode;
+    /** Reverse order */
+    reverse?: boolean;
+}
+interface TimelineItemProps extends HTMLAttributes<HTMLLIElement> {
+    /** Custom dot */
+    dot?: ReactNode;
+    /** Dot color */
+    color?: 'primary' | 'success' | 'danger' | 'warning' | 'gray';
+    /** Label (for alternate mode) */
+    label?: ReactNode;
+    /** Position override */
+    position?: 'left' | 'right';
+}
+declare const Timeline: react.ForwardRefExoticComponent<TimelineProps & react.RefAttributes<HTMLUListElement>>;
+declare const TimelineItem: react.ForwardRefExoticComponent<TimelineItemProps & react.RefAttributes<HTMLLIElement>>;
+
+interface StatisticProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title' | 'prefix'> {
+    /** Statistic title */
+    title?: ReactNode;
+    /** Statistic value */
+    value: ReactNode;
+    /** Value prefix */
+    prefix?: ReactNode;
+    /** Value suffix */
+    suffix?: ReactNode;
+    /** Precision for number values */
+    precision?: number;
+    /** Loading state */
+    loading?: boolean;
+    /** Value style */
+    valueStyle?: React.CSSProperties;
+    /** Formatter function */
+    formatter?: (value: ReactNode) => ReactNode;
+}
+declare const Statistic: react.ForwardRefExoticComponent<StatisticProps & react.RefAttributes<HTMLDivElement>>;
+interface StatisticGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Divider between items */
+    divider?: boolean;
+}
+declare const StatisticGroup: react.ForwardRefExoticComponent<StatisticGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+interface EmptyProps extends HTMLAttributes<HTMLDivElement> {
+    /** Custom image/icon */
+    image?: ReactNode;
+    /** Image size */
+    imageSize?: number;
+    /** Description text */
+    description?: ReactNode;
+    /** Action buttons */
+    children?: ReactNode;
+}
+declare const Empty: react.ForwardRefExoticComponent<EmptyProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ImageProps extends ImgHTMLAttributes<HTMLImageElement> {
+    /** Fallback content when image fails to load */
+    fallback?: ReactNode;
+    /** Preview on click */
+    preview?: boolean;
+    /** Placeholder while loading */
+    placeholder?: ReactNode;
+    /** Border radius */
+    rounded?: boolean | 'sm' | 'md' | 'lg' | 'full';
+    /** Object fit */
+    fit?: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+}
+declare const Image: react.ForwardRefExoticComponent<ImageProps & react.RefAttributes<HTMLImageElement>>;
+
+type ResultStatus = 'success' | 'error' | 'info' | 'warning' | '404' | '403' | '500';
+interface ResultProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Result status */
+    status?: ResultStatus;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Title */
+    title?: ReactNode;
+    /** Subtitle/description */
+    subtitle?: ReactNode;
+    /** Extra content (buttons) */
+    extra?: ReactNode;
+}
+declare const Result: react.ForwardRefExoticComponent<ResultProps & react.RefAttributes<HTMLDivElement>>;
+
+type SkeletonVariant = 'text' | 'circular' | 'rectangular' | 'rounded';
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    /** Skeleton variant */
+    variant?: SkeletonVariant;
+    /** Width */
+    width?: number | string;
+    /** Height */
+    height?: number | string;
+    /** Animation */
+    animation?: 'pulse' | 'wave' | false;
+    /** Number of lines (for text variant) */
+    lines?: number;
+}
+declare const Skeleton: react.ForwardRefExoticComponent<SkeletonProps & react.RefAttributes<HTMLDivElement>>;
+interface SkeletonAvatarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Avatar size */
+    size?: number;
+    /** Animation */
+    animation?: 'pulse' | 'wave' | false;
+}
+declare const SkeletonAvatar: react.ForwardRefExoticComponent<SkeletonAvatarProps & react.RefAttributes<HTMLDivElement>>;
+interface SkeletonCardProps extends HTMLAttributes<HTMLDivElement> {
+    /** Show avatar */
+    avatar?: boolean;
+    /** Number of text lines */
+    lines?: number;
+    /** Animation */
+    animation?: 'pulse' | 'wave' | false;
+}
+declare const SkeletonCard: react.ForwardRefExoticComponent<SkeletonCardProps & react.RefAttributes<HTMLDivElement>>;
+
+interface RateProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Current value */
+    value?: number;
+    /** Default value */
+    defaultValue?: number;
+    /** Number of stars */
+    count?: number;
+    /** Allow half rating */
+    allowHalf?: boolean;
+    /** Allow clear */
+    allowClear?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Read only */
+    readOnly?: boolean;
+    /** Custom character */
+    character?: ReactNode;
+    /** Change callback */
+    onChange?: (value: number) => void;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Tooltips for each star */
+    tooltips?: string[];
+}
+declare const Rate: react.ForwardRefExoticComponent<RateProps & react.RefAttributes<HTMLDivElement>>;
+
+interface BackTopProps extends HTMLAttributes<HTMLDivElement> {
+    /** Scroll target (defaults to window) */
+    target?: () => HTMLElement | Window;
+    /** Visibility threshold (px from top) */
+    visibilityHeight?: number;
+    /** Duration of scroll animation (ms) */
+    duration?: number;
+    /** Custom content */
+    children?: ReactNode;
+    /** Click callback */
+    onClick?: () => void;
+}
+declare const BackTop: react.ForwardRefExoticComponent<BackTopProps & react.RefAttributes<HTMLDivElement>>;
+
+type ButtonGroupSize = 'sm' | 'md' | 'lg';
+type ButtonGroupVariant = 'solid' | 'outline' | 'ghost';
+interface ButtonGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Size of buttons in the group */
+    size?: ButtonGroupSize;
+    /** Variant of buttons in the group */
+    variant?: ButtonGroupVariant;
+    /** Disable all buttons */
+    disabled?: boolean;
+    /** Vertical orientation */
+    vertical?: boolean;
+    /** Attached buttons (no gap) */
+    attached?: boolean;
+}
+declare const ButtonGroup: react.ForwardRefExoticComponent<ButtonGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface IconProps extends SVGAttributes<SVGSVGElement> {
+    /** Icon size */
+    size?: IconSize;
+    /** Icon color */
+    color?: string;
+    /** Spin animation */
+    spin?: boolean;
+    /** Icon name (for icon fonts) */
+    name?: string;
+}
+declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<SVGSVGElement>>;
+declare const Icons: {
+    Check: () => react_jsx_runtime.JSX.Element;
+    X: () => react_jsx_runtime.JSX.Element;
+    ChevronDown: () => react_jsx_runtime.JSX.Element;
+    ChevronUp: () => react_jsx_runtime.JSX.Element;
+    ChevronLeft: () => react_jsx_runtime.JSX.Element;
+    ChevronRight: () => react_jsx_runtime.JSX.Element;
+    Search: () => react_jsx_runtime.JSX.Element;
+    Menu: () => react_jsx_runtime.JSX.Element;
+    Plus: () => react_jsx_runtime.JSX.Element;
+    Minus: () => react_jsx_runtime.JSX.Element;
+    Info: () => react_jsx_runtime.JSX.Element;
+    Warning: () => react_jsx_runtime.JSX.Element;
+    Error: () => react_jsx_runtime.JSX.Element;
+    Success: () => react_jsx_runtime.JSX.Element;
+    Loading: () => react_jsx_runtime.JSX.Element;
+};
+
+type IconButtonSize = 'sm' | 'md' | 'lg';
+type IconButtonVariant = 'solid' | 'outline' | 'ghost' | 'light';
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Button size */
+    size?: IconButtonSize;
+    /** Button variant */
+    variant?: IconButtonVariant;
+    /** Color scheme */
+    color?: 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    /** Icon element */
+    icon: ReactNode;
+    /** Loading state */
+    loading?: boolean;
+    /** Rounded style */
+    rounded?: boolean;
+    /** Accessible label */
+    'aria-label': string;
+}
+declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+type ChipSize = 'sm' | 'md' | 'lg';
+type ChipVariant = 'solid' | 'outline' | 'light';
+type ChipColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+interface ChipProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Chip size */
+    size?: ChipSize;
+    /** Chip variant */
+    variant?: ChipVariant;
+    /** Color scheme */
+    color?: ChipColor;
+    /** Avatar or icon on left */
+    avatar?: ReactNode;
+    /** Start content */
+    startContent?: ReactNode;
+    /** End content */
+    endContent?: ReactNode;
+    /** Deletable chip */
+    onClose?: () => void;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Clickable chip */
+    clickable?: boolean;
+}
+declare const Chip: react.ForwardRefExoticComponent<ChipProps & react.RefAttributes<HTMLSpanElement>>;
+interface ChipGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Gap between chips */
+    gap?: 'sm' | 'md' | 'lg';
+}
+declare const ChipGroup: react.ForwardRefExoticComponent<ChipGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+type CloseButtonSize = 'sm' | 'md' | 'lg';
+interface CloseButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Button size */
+    size?: CloseButtonSize;
+    /** Accessible label */
+    'aria-label'?: string;
+}
+declare const CloseButton: react.ForwardRefExoticComponent<CloseButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface CodeProps extends HTMLAttributes<HTMLElement> {
+    /** Color scheme */
+    color?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+}
+declare const Code: react.ForwardRefExoticComponent<CodeProps & react.RefAttributes<HTMLElement>>;
+interface CodeBlockProps extends HTMLAttributes<HTMLPreElement> {
+    /** Language for syntax highlighting */
+    language?: string;
+    /** Show line numbers */
+    showLineNumbers?: boolean;
+    /** Filename header */
+    filename?: string;
+    /** Copy button */
+    copyable?: boolean;
+    /** Code content */
+    children: string;
+}
+declare const CodeBlock: react.ForwardRefExoticComponent<CodeBlockProps & react.RefAttributes<HTMLPreElement>>;
+
+type StackDirection = 'row' | 'column' | 'row-reverse' | 'column-reverse';
+type StackAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+type StackJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+type StackSpacing = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface StackProps extends HTMLAttributes<HTMLDivElement> {
+    /** Stack direction */
+    direction?: StackDirection;
+    /** Align items */
+    align?: StackAlign;
+    /** Justify content */
+    justify?: StackJustify;
+    /** Gap between items */
+    spacing?: StackSpacing;
+    /** Wrap items */
+    wrap?: boolean;
+    /** Divider between items */
+    divider?: boolean;
+}
+declare const Stack: react.ForwardRefExoticComponent<StackProps & react.RefAttributes<HTMLDivElement>>;
+interface VStackProps extends Omit<StackProps, 'direction'> {
+}
+declare const VStack: react.ForwardRefExoticComponent<VStackProps & react.RefAttributes<HTMLDivElement>>;
+interface HStackProps extends Omit<StackProps, 'direction'> {
+}
+declare const HStack: react.ForwardRefExoticComponent<HStackProps & react.RefAttributes<HTMLDivElement>>;
+
+interface AspectRatioProps extends HTMLAttributes<HTMLDivElement> {
+    /** Aspect ratio (e.g., 16/9, 4/3, 1) */
+    ratio?: number;
+}
+declare const AspectRatio: react.ForwardRefExoticComponent<AspectRatioProps & react.RefAttributes<HTMLDivElement>>;
+
+interface MasonryProps extends HTMLAttributes<HTMLDivElement> {
+    /** Number of columns */
+    columns?: number | {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    /** Gap between items */
+    gap?: 'none' | 'sm' | 'md' | 'lg';
+}
+declare const Masonry: react.ForwardRefExoticComponent<MasonryProps & react.RefAttributes<HTMLDivElement>>;
+interface MasonryItemProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const MasonryItem: react.ForwardRefExoticComponent<MasonryItemProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SplitterProps extends HTMLAttributes<HTMLDivElement> {
+    /** Orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Initial sizes (percentages) */
+    defaultSizes?: number[];
+    /** Minimum size for panels (px) */
+    minSize?: number;
+    /** Gutter size (px) */
+    gutterSize?: number;
+    /** Disable resizing */
+    disabled?: boolean;
+}
+declare const Splitter: react.ForwardRefExoticComponent<SplitterProps & react.RefAttributes<HTMLDivElement>>;
+interface SplitterPanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Default size (percentage) */
+    defaultSize?: number;
+    /** Minimum size (px) */
+    minSize?: number;
+    /** Maximum size (px) */
+    maxSize?: number;
+    /** Collapsible */
+    collapsible?: boolean;
+}
+declare const SplitterPanel: react.ForwardRefExoticComponent<SplitterPanelProps & react.RefAttributes<HTMLDivElement>>;
+
+type LinkVariant = 'default' | 'subtle' | 'underline';
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Link variant */
+    variant?: LinkVariant;
+    /** Color */
+    color?: 'primary' | 'secondary' | 'inherit';
+    /** External link */
+    external?: boolean;
+    /** Show external icon */
+    showExternalIcon?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const Link: react.ForwardRefExoticComponent<LinkProps & react.RefAttributes<HTMLAnchorElement>>;
+
+interface NavbarProps extends HTMLAttributes<HTMLElement> {
+    /** Fixed position */
+    position?: 'static' | 'sticky' | 'fixed';
+    /** Max width */
+    maxWidth?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    /** Bordered bottom */
+    bordered?: boolean;
+    /** Blur background */
+    blurred?: boolean;
+}
+declare const Navbar: react.ForwardRefExoticComponent<NavbarProps & react.RefAttributes<HTMLElement>>;
+interface NavbarBrandProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const NavbarBrand: react.ForwardRefExoticComponent<NavbarBrandProps & react.RefAttributes<HTMLDivElement>>;
+interface NavbarContentProps extends HTMLAttributes<HTMLUListElement> {
+    /** Justify content */
+    justify?: 'start' | 'center' | 'end';
+}
+declare const NavbarContent: react.ForwardRefExoticComponent<NavbarContentProps & react.RefAttributes<HTMLUListElement>>;
+interface NavbarItemProps extends HTMLAttributes<HTMLLIElement> {
+    /** Active state */
+    active?: boolean;
+}
+declare const NavbarItem: react.ForwardRefExoticComponent<NavbarItemProps & react.RefAttributes<HTMLLIElement>>;
+interface NavbarMenuToggleProps extends HTMLAttributes<HTMLButtonElement> {
+    /** Is menu open */
+    isOpen?: boolean;
+}
+declare const NavbarMenuToggle: react.ForwardRefExoticComponent<NavbarMenuToggleProps & react.RefAttributes<HTMLButtonElement>>;
+interface NavbarMenuProps extends HTMLAttributes<HTMLDivElement> {
+    /** Is menu open */
+    isOpen?: boolean;
+}
+declare const NavbarMenu: react.ForwardRefExoticComponent<NavbarMenuProps & react.RefAttributes<HTMLDivElement>>;
+interface NavbarMenuItemProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const NavbarMenuItem: react.ForwardRefExoticComponent<NavbarMenuItemProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SidebarContextValue {
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+}
+declare const useSidebar: () => SidebarContextValue;
+interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    /** Collapsed state */
+    collapsed?: boolean;
+    /** Default collapsed state */
+    defaultCollapsed?: boolean;
+    /** On collapse change */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Width when expanded */
+    width?: number;
+    /** Width when collapsed */
+    collapsedWidth?: number;
+    /** Position */
+    position?: 'left' | 'right';
+}
+declare const Sidebar: react.ForwardRefExoticComponent<SidebarProps & react.RefAttributes<HTMLElement>>;
+interface SidebarHeaderProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarHeader: react.ForwardRefExoticComponent<SidebarHeaderProps & react.RefAttributes<HTMLDivElement>>;
+interface SidebarContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarContent: react.ForwardRefExoticComponent<SidebarContentProps & react.RefAttributes<HTMLDivElement>>;
+interface SidebarFooterProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarFooter: react.ForwardRefExoticComponent<SidebarFooterProps & react.RefAttributes<HTMLDivElement>>;
+interface SidebarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Group label */
+    label?: ReactNode;
+}
+declare const SidebarGroup: react.ForwardRefExoticComponent<SidebarGroupProps & react.RefAttributes<HTMLDivElement>>;
+interface SidebarItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Icon */
+    icon?: ReactNode;
+    /** Active state */
+    active?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const SidebarItem: react.ForwardRefExoticComponent<SidebarItemProps & react.RefAttributes<HTMLDivElement>>;
+interface SidebarToggleProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare const SidebarToggle: react.ForwardRefExoticComponent<SidebarToggleProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface AnchorItem {
+    key: string;
+    href: string;
+    title: ReactNode;
+    children?: AnchorItem[];
+}
+interface AnchorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Anchor items */
+    items: AnchorItem[];
+    /** Offset from top (px) */
+    offsetTop?: number;
+    /** Target offset (px) */
+    targetOffset?: number;
+    /** Show ink indicator */
+    showInk?: boolean;
+    /** Affix mode */
+    affix?: boolean;
+    /** Current active link */
+    activeLink?: string;
+    /** On change callback */
+    onChange?: (activeLink: string) => void;
+    /** On click callback */
+    onLinkClick?: (e: React.MouseEvent, link: {
+        title: ReactNode;
+        href: string;
+    }) => void;
+}
+declare const Anchor: react.ForwardRefExoticComponent<AnchorProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+    shortcut?: string[];
+    group?: string;
+    onSelect?: () => void;
+    disabled?: boolean;
+}
+interface CommandPaletteProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Is palette open */
+    open?: boolean;
+    /** On open change */
+    onOpenChange?: (open: boolean) => void;
+    /** Command items */
+    items: CommandItem[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Empty state text */
+    emptyText?: string;
+    /** On item select */
+    onSelect?: (item: CommandItem) => void;
+    /** Filter function */
+    filter?: (item: CommandItem, search: string) => boolean;
+}
+declare const CommandPalette: react.ForwardRefExoticComponent<CommandPaletteProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ContextMenuItem {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    danger?: boolean;
+    children?: ContextMenuItem[];
+    onSelect?: () => void;
+}
+interface ContextMenuProps extends HTMLAttributes<HTMLDivElement> {
+    /** Menu items */
+    items: ContextMenuItem[];
+    /** Trigger element */
+    children: ReactNode;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const ContextMenu: react.ForwardRefExoticComponent<ContextMenuProps & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+interface SpeedDialAction {
+    key: string;
+    icon: ReactNode;
+    label?: string;
+    onClick?: () => void;
+    disabled?: boolean;
+}
+interface SpeedDialProps extends HTMLAttributes<HTMLDivElement> {
+    /** Actions */
+    actions: SpeedDialAction[];
+    /** Main button icon */
+    icon?: ReactNode;
+    /** Open icon (when expanded) */
+    openIcon?: ReactNode;
+    /** Direction */
+    direction?: 'up' | 'down' | 'left' | 'right';
+    /** Position */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Controlled open state */
+    open?: boolean;
+    /** On open change */
+    onOpenChange?: (open: boolean) => void;
+    /** Show labels */
+    showLabels?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const SpeedDial: react.ForwardRefExoticComponent<SpeedDialProps & react.RefAttributes<HTMLDivElement>>;
+
+interface BottomNavigationProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'> {
+    /** Active item key */
+    activeKey?: string;
+    /** On change callback */
+    onChange?: (key: string) => void;
+    /** Show labels */
+    showLabels?: boolean;
+    /** Hide on scroll */
+    hideOnScroll?: boolean;
+}
+declare const BottomNavigation: react.ForwardRefExoticComponent<BottomNavigationProps & react.RefAttributes<HTMLElement>>;
+interface BottomNavigationItemProps extends HTMLAttributes<HTMLButtonElement> {
+    /** Item key */
+    itemKey: string;
+    /** Icon */
+    icon: ReactNode;
+    /** Label */
+    label?: string;
+    /** Active state */
+    active?: boolean;
+    /** Badge count */
+    badge?: number | boolean;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const BottomNavigationItem: react.ForwardRefExoticComponent<BottomNavigationItemProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface MenubarItem {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    children?: MenubarItem[];
+    onSelect?: () => void;
+    type?: 'item' | 'separator' | 'checkbox' | 'radio';
+    checked?: boolean;
+}
+interface MenubarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Loop keyboard navigation */
+    loop?: boolean;
+}
+declare const Menubar: react.ForwardRefExoticComponent<MenubarProps & react.RefAttributes<HTMLDivElement>>;
+interface MenubarMenuProps extends HTMLAttributes<HTMLDivElement> {
+    /** Trigger label */
+    trigger: ReactNode;
+    /** Menu items */
+    items: MenubarItem[];
+}
+declare const MenubarMenu: react.ForwardRefExoticComponent<MenubarMenuProps & react.RefAttributes<HTMLDivElement>>;
+
+interface NavigationMenuProps extends HTMLAttributes<HTMLElement> {
+    /** Default active item */
+    defaultValue?: string;
+    /** Controlled active value */
+    value?: string;
+    /** On value change */
+    onValueChange?: (value: string) => void;
+    /** Orientation */
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const NavigationMenu: react.ForwardRefExoticComponent<NavigationMenuProps & react.RefAttributes<HTMLElement>>;
+interface NavigationMenuItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Item value */
+    value: string;
+}
+declare const NavigationMenuItem: react.ForwardRefExoticComponent<NavigationMenuItemProps & react.RefAttributes<HTMLDivElement>>;
+interface NavigationMenuTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+    /** Disable chevron */
+    hideChevron?: boolean;
+}
+declare const NavigationMenuTrigger: react.ForwardRefExoticComponent<NavigationMenuTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+interface NavigationMenuContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const NavigationMenuContent: react.ForwardRefExoticComponent<NavigationMenuContentProps & react.RefAttributes<HTMLDivElement>>;
+interface NavigationMenuLinkProps extends HTMLAttributes<HTMLAnchorElement> {
+    /** Link href */
+    href?: string;
+    /** Active state */
+    active?: boolean;
+}
+declare const NavigationMenuLink: react.ForwardRefExoticComponent<NavigationMenuLinkProps & react.RefAttributes<HTMLAnchorElement>>;
+interface NavigationMenuViewportProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const NavigationMenuViewport: react.ForwardRefExoticComponent<NavigationMenuViewportProps & react.RefAttributes<HTMLDivElement>>;
+interface NavigationMenuIndicatorProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const NavigationMenuIndicator: react.ForwardRefExoticComponent<NavigationMenuIndicatorProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DatePickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'size'> {
+    /** Selected date */
+    value?: Date | null;
+    /** On change callback */
+    onChange?: (date: Date | null) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Date format */
+    format?: string;
+    /** Minimum date */
+    minDate?: Date;
+    /** Maximum date */
+    maxDate?: Date;
+    /** Disabled dates */
+    disabledDates?: Date[];
+    /** Clearable */
+    clearable?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+}
+declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface DateRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface DateRangePickerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Selected date range */
+    value?: DateRange;
+    /** On change callback */
+    onChange?: (range: DateRange) => void;
+    /** Start placeholder */
+    startPlaceholder?: string;
+    /** End placeholder */
+    endPlaceholder?: string;
+    /** Minimum date */
+    minDate?: Date;
+    /** Maximum date */
+    maxDate?: Date;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const DateRangePicker: react.ForwardRefExoticComponent<DateRangePickerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TimePickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'size'> {
+    /** Selected time */
+    value?: string;
+    /** On change callback */
+    onChange?: (time: string) => void;
+    /** Use 12-hour format */
+    use12Hours?: boolean;
+    /** Show seconds */
+    showSeconds?: boolean;
+    /** Hour step */
+    hourStep?: number;
+    /** Minute step */
+    minuteStep?: number;
+    /** Second step */
+    secondStep?: number;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Clearable */
+    clearable?: boolean;
+}
+declare const TimePicker: react.ForwardRefExoticComponent<TimePickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface AutocompleteOption {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+}
+interface AutocompleteProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'size'> {
+    /** Options */
+    options: AutocompleteOption[];
+    /** Selected value */
+    value?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** On search callback */
+    onSearch?: (value: string) => void;
+    /** Loading state */
+    loading?: boolean;
+    /** Allow free text */
+    freeSolo?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Empty text */
+    emptyText?: string;
+}
+declare const Autocomplete: react.ForwardRefExoticComponent<AutocompleteProps & react.RefAttributes<HTMLInputElement>>;
+
+interface UploadFile {
+    uid: string;
+    name: string;
+    size: number;
+    type: string;
+    status: 'uploading' | 'done' | 'error';
+    percent?: number;
+    url?: string;
+    originFile?: File;
+}
+interface UploadProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** File list */
+    fileList?: UploadFile[];
+    /** On change callback */
+    onChange?: (fileList: UploadFile[]) => void;
+    /** Custom upload handler */
+    customRequest?: (file: File) => Promise<string>;
+    /** Accept file types */
+    accept?: string;
+    /** Multiple files */
+    multiple?: boolean;
+    /** Max file count */
+    maxCount?: number;
+    /** Max file size (bytes) */
+    maxSize?: number;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Show file list */
+    showFileList?: boolean;
+    /** List type */
+    listType?: 'text' | 'picture' | 'picture-card';
+    /** Custom content */
+    children?: ReactNode;
+}
+declare const Upload: react.ForwardRefExoticComponent<UploadProps & react.RefAttributes<HTMLDivElement>>;
+
+interface NumberInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'type' | 'prefix' | 'size'> {
+    /** Value */
+    value?: number;
+    /** On change callback */
+    onChange?: (value: number | undefined) => void;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step value */
+    step?: number;
+    /** Precision */
+    precision?: number;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Hide controls */
+    hideControls?: boolean;
+    /** Prefix */
+    prefix?: React.ReactNode;
+    /** Suffix */
+    suffix?: React.ReactNode;
+}
+declare const NumberInput: react.ForwardRefExoticComponent<NumberInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface ColorPickerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Selected color */
+    value?: string;
+    /** On change callback */
+    onChange?: (color: string) => void;
+    /** Preset colors */
+    presets?: string[];
+    /** Show alpha slider */
+    showAlpha?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Format */
+    format?: 'hex' | 'rgb' | 'hsl';
+}
+declare const ColorPicker: react.ForwardRefExoticComponent<ColorPickerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface MentionOption {
+    value: string;
+    label: string;
+    avatar?: string;
+}
+interface MentionsProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange'> {
+    /** Mention options */
+    options: MentionOption[];
+    /** Value */
+    value?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** On mention callback */
+    onMention?: (option: MentionOption) => void;
+    /** Trigger character */
+    trigger?: string;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+}
+declare const Mentions: react.ForwardRefExoticComponent<MentionsProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface CascaderOption {
+    value: string;
+    label: ReactNode;
+    children?: CascaderOption[];
+    disabled?: boolean;
+}
+interface CascaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Options */
+    options: CascaderOption[];
+    /** Selected value path */
+    value?: string[];
+    /** On change callback */
+    onChange?: (value: string[], options: CascaderOption[]) => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Show full path in input */
+    showFullPath?: boolean;
+    /** Separator for display */
+    separator?: string;
+}
+declare const Cascader: react.ForwardRefExoticComponent<CascaderProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TreeSelectNode {
+    key: string;
+    title: ReactNode;
+    value: string;
+    children?: TreeSelectNode[];
+    disabled?: boolean;
+    selectable?: boolean;
+}
+interface TreeSelectProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Tree data */
+    treeData: TreeSelectNode[];
+    /** Selected value(s) */
+    value?: string | string[];
+    /** On change callback */
+    onChange?: (value: string | string[]) => void;
+    /** Multiple selection */
+    multiple?: boolean;
+    /** Placeholder */
+    placeholder?: string;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Show checkbox */
+    showCheckbox?: boolean;
+    /** Default expanded keys */
+    defaultExpandedKeys?: string[];
+}
+declare const TreeSelect: react.ForwardRefExoticComponent<TreeSelectProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TransferItem {
+    key: string;
+    title: ReactNode;
+    description?: string;
+    disabled?: boolean;
+}
+interface TransferProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Data source */
+    dataSource: TransferItem[];
+    /** Target keys */
+    targetKeys?: string[];
+    /** On change callback */
+    onChange?: (targetKeys: string[], direction: 'left' | 'right', moveKeys: string[]) => void;
+    /** Titles for both lists */
+    titles?: [ReactNode, ReactNode];
+    /** Show search */
+    showSearch?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** One way mode */
+    oneWay?: boolean;
+}
+declare const Transfer: react.ForwardRefExoticComponent<TransferProps & react.RefAttributes<HTMLDivElement>>;
+
+interface InputOTPProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Number of inputs */
+    length?: number;
+    /** Value */
+    value?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** On complete callback */
+    onComplete?: (value: string) => void;
+    /** Mask input */
+    mask?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Auto focus first input */
+    autoFocus?: boolean;
+    /** Type */
+    type?: 'numeric' | 'alphanumeric';
+}
+declare const InputOTP: react.ForwardRefExoticComponent<InputOTPProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TagsInputProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Tags */
+    value?: string[];
+    /** On change callback */
+    onChange?: (tags: string[]) => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Max tags */
+    maxTags?: number;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Allow duplicates */
+    allowDuplicates?: boolean;
+    /** Separator keys */
+    separatorKeys?: string[];
+}
+declare const TagsInput: react.ForwardRefExoticComponent<TagsInputProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DropzoneProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onDrop'> {
+    /** On drop callback */
+    onDrop?: (files: File[]) => void;
+    /** Accept file types */
+    accept?: string;
+    /** Multiple files */
+    multiple?: boolean;
+    /** Max file size (bytes) */
+    maxSize?: number;
+    /** Max files */
+    maxFiles?: number;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Custom content */
+    children?: ReactNode;
+    /** Loading state */
+    loading?: boolean;
+}
+declare const Dropzone: react.ForwardRefExoticComponent<DropzoneProps & react.RefAttributes<HTMLDivElement>>;
+
+interface PasswordInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Show strength indicator */
+    showStrength?: boolean;
+    /** Visible by default */
+    defaultVisible?: boolean;
+}
+declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface PinInputProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Number of inputs */
+    length?: number;
+    /** Value */
+    value?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** On complete callback */
+    onComplete?: (value: string) => void;
+    /** Mask input */
+    mask?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Type */
+    type?: 'numeric' | 'alphanumeric';
+    /** Placeholder character */
+    placeholder?: string;
+    /** Auto focus */
+    autoFocus?: boolean;
+}
+declare const PinInput: react.ForwardRefExoticComponent<PinInputProps & react.RefAttributes<HTMLDivElement>>;
+
+interface FieldsetProps extends HTMLAttributes<HTMLFieldSetElement> {
+    /** Legend/title */
+    legend?: ReactNode;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Variant */
+    variant?: 'default' | 'outlined' | 'filled';
+}
+declare const Fieldset: react.ForwardRefExoticComponent<FieldsetProps & react.RefAttributes<HTMLFieldSetElement>>;
+interface FieldProps extends HTMLAttributes<HTMLDivElement> {
+    /** Field label */
+    label?: ReactNode;
+    /** Label position */
+    labelPosition?: 'top' | 'left';
+    /** Required indicator */
+    required?: boolean;
+    /** Help text */
+    help?: ReactNode;
+    /** Error text */
+    error?: ReactNode;
+}
+declare const Field: react.ForwardRefExoticComponent<FieldProps & react.RefAttributes<HTMLDivElement>>;
+
+interface EditableProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'onSubmit'> {
+    /** Value */
+    value?: string;
+    /** Default value */
+    defaultValue?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** On submit callback */
+    onSubmit?: (value: string) => void;
+    /** On cancel callback */
+    onCancel?: () => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Start in edit mode */
+    startWithEditView?: boolean;
+    /** Submit on blur */
+    submitOnBlur?: boolean;
+    /** Select all on focus */
+    selectAllOnFocus?: boolean;
+    /** As element type */
+    as?: 'span' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p';
+}
+declare const Editable: react.ForwardRefExoticComponent<EditableProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DataGridColumn<T> {
+    key: string;
+    title: ReactNode;
+    dataIndex?: keyof T;
+    width?: number | string;
+    minWidth?: number;
+    sortable?: boolean;
+    filterable?: boolean;
+    resizable?: boolean;
+    fixed?: 'left' | 'right';
+    render?: (value: any, record: T, index: number) => ReactNode;
+}
+interface DataGridProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Columns configuration */
+    columns: DataGridColumn<T>[];
+    /** Data source */
+    dataSource: T[];
+    /** Row key */
+    rowKey: keyof T | ((record: T) => string);
+    /** Loading state */
+    loading?: boolean;
+    /** Bordered */
+    bordered?: boolean;
+    /** Striped rows */
+    striped?: boolean;
+    /** Hover effect */
+    hover?: boolean;
+    /** Fixed header */
+    stickyHeader?: boolean;
+    /** Height */
+    height?: number | string;
+    /** Empty text */
+    emptyText?: ReactNode;
+    /** Row selection */
+    rowSelection?: {
+        selectedRowKeys: string[];
+        onChange: (selectedRowKeys: string[]) => void;
+    };
+    /** On row click */
+    onRowClick?: (record: T, index: number) => void;
+}
+declare const DataGrid: react.ForwardRefExoticComponent<DataGridProps<any> & react.RefAttributes<HTMLDivElement>>;
+
+interface CarouselProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Autoplay */
+    autoplay?: boolean;
+    /** Autoplay interval (ms) */
+    interval?: number;
+    /** Show arrows */
+    arrows?: boolean;
+    /** Show dots */
+    dots?: boolean;
+    /** Dots position */
+    dotsPosition?: 'bottom' | 'top' | 'left' | 'right';
+    /** Loop infinitely */
+    loop?: boolean;
+    /** Pause on hover */
+    pauseOnHover?: boolean;
+    /** On slide change */
+    onChange?: (index: number) => void;
+}
+declare const Carousel: react.ForwardRefExoticComponent<CarouselProps & react.RefAttributes<HTMLDivElement>>;
+interface CarouselItemProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const CarouselItem: react.ForwardRefExoticComponent<CarouselItemProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TreeNode {
+    key: string;
+    title: ReactNode;
+    children?: TreeNode[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+    icon?: ReactNode;
+}
+interface TreeProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Tree data */
+    treeData: TreeNode[];
+    /** Expanded keys */
+    expandedKeys?: string[];
+    /** Default expanded keys */
+    defaultExpandedKeys?: string[];
+    /** Selected keys */
+    selectedKeys?: string[];
+    /** Default selected keys */
+    defaultSelectedKeys?: string[];
+    /** Checked keys (for checkable tree) */
+    checkedKeys?: string[];
+    /** Checkable tree */
+    checkable?: boolean;
+    /** Multiple selection */
+    multiple?: boolean;
+    /** Show lines */
+    showLine?: boolean;
+    /** Show icon */
+    showIcon?: boolean;
+    /** On expand */
+    onExpand?: (expandedKeys: string[], node: TreeNode, expanded: boolean) => void;
+    /** On select */
+    onSelect?: (selectedKeys: string[], node: TreeNode, selected: boolean) => void;
+    /** On check */
+    onCheck?: (checkedKeys: string[], node: TreeNode, checked: boolean) => void;
+}
+declare const Tree: react.ForwardRefExoticComponent<TreeProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CalendarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Selected date */
+    value?: Date;
+    /** On change callback */
+    onChange?: (date: Date) => void;
+    /** Mode */
+    mode?: 'month' | 'year';
+    /** On mode change */
+    onModeChange?: (mode: 'month' | 'year') => void;
+    /** Full screen mode */
+    fullscreen?: boolean;
+    /** Disabled dates */
+    disabledDate?: (date: Date) => boolean;
+    /** Custom date cell render */
+    dateCellRender?: (date: Date) => ReactNode;
+    /** Custom month cell render */
+    monthCellRender?: (month: number) => ReactNode;
+    /** Header render */
+    headerRender?: (config: {
+        value: Date;
+        onChange: (date: Date) => void;
+    }) => ReactNode;
+}
+declare const Calendar: react.ForwardRefExoticComponent<CalendarProps & react.RefAttributes<HTMLDivElement>>;
+
+interface QRCodeProps extends HTMLAttributes<HTMLDivElement> {
+    /** Value to encode */
+    value: string;
+    /** Size in pixels */
+    size?: number;
+    /** Background color */
+    bgColor?: string;
+    /** Foreground color */
+    fgColor?: string;
+    /** Error correction level */
+    level?: 'L' | 'M' | 'Q' | 'H';
+    /** Include margin */
+    includeMargin?: boolean;
+    /** Icon in center */
+    icon?: string;
+    /** Icon size */
+    iconSize?: number;
+    /** Status */
+    status?: 'active' | 'expired' | 'loading';
+    /** On refresh (for expired) */
+    onRefresh?: () => void;
+}
+declare const QRCode: react.ForwardRefExoticComponent<QRCodeProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SegmentedOption {
+    value: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+interface SegmentedProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Options */
+    options: (string | SegmentedOption)[];
+    /** Selected value */
+    value?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Block mode (full width) */
+    block?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const Segmented: react.ForwardRefExoticComponent<SegmentedProps & react.RefAttributes<HTMLDivElement>>;
+
+interface KbdProps extends HTMLAttributes<HTMLElement> {
+    /** Key combination (array for multiple keys) */
+    keys?: string | string[];
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const Kbd: react.ForwardRefExoticComponent<KbdProps & react.RefAttributes<HTMLElement>>;
+
+interface ScrollAreaProps extends HTMLAttributes<HTMLDivElement> {
+    /** Scroll direction */
+    type?: 'auto' | 'always' | 'scroll' | 'hover';
+    /** Scrollbar size */
+    scrollbarSize?: number;
+    /** Hide delay (ms) */
+    scrollHideDelay?: number;
+    /** Orientation */
+    orientation?: 'vertical' | 'horizontal' | 'both';
+}
+declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
+
+interface HoverCardProps extends HTMLAttributes<HTMLDivElement> {
+    /** Trigger element */
+    trigger: ReactNode;
+    /** Open delay (ms) */
+    openDelay?: number;
+    /** Close delay (ms) */
+    closeDelay?: number;
+    /** Placement */
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    /** Disabled */
+    disabled?: boolean;
+}
+declare const HoverCard: react.ForwardRefExoticComponent<HoverCardProps & react.RefAttributes<HTMLDivElement>>;
+interface HoverCardHeaderProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const HoverCardHeader: react.ForwardRefExoticComponent<HoverCardHeaderProps & react.RefAttributes<HTMLDivElement>>;
+interface HoverCardBodyProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const HoverCardBody: react.ForwardRefExoticComponent<HoverCardBodyProps & react.RefAttributes<HTMLDivElement>>;
+interface HoverCardFooterProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const HoverCardFooter: react.ForwardRefExoticComponent<HoverCardFooterProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ToggleProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Pressed state */
+    pressed?: boolean;
+    /** Default pressed state */
+    defaultPressed?: boolean;
+    /** On pressed change */
+    onPressedChange?: (pressed: boolean) => void;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Variant */
+    variant?: 'default' | 'outline';
+}
+declare const Toggle: react.ForwardRefExoticComponent<ToggleProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ToggleGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Selection type */
+    type?: 'single' | 'multiple';
+    /** Selected value(s) */
+    value?: string | string[];
+    /** Default value(s) */
+    defaultValue?: string | string[];
+    /** On value change */
+    onValueChange?: (value: string | string[]) => void;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Variant */
+    variant?: 'default' | 'outline';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Orientation */
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const ToggleGroup: react.ForwardRefExoticComponent<ToggleGroupProps & react.RefAttributes<HTMLDivElement>>;
+interface ToggleGroupItemProps extends HTMLAttributes<HTMLButtonElement> {
+    /** Item value */
+    value: string;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare const ToggleGroupItem: react.ForwardRefExoticComponent<ToggleGroupItemProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface SnippetProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onCopy'> {
+    /** Code content */
+    children: string;
+    /** Symbol prefix */
+    symbol?: string;
+    /** Color variant */
+    color?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Show copy button */
+    copyable?: boolean;
+    /** Disable copy */
+    disableCopy?: boolean;
+    /** Hide symbol */
+    hideSymbol?: boolean;
+    /** Copy text (overrides children) */
+    copyText?: string;
+    /** On copy callback */
+    onCopy?: (text: string) => void;
+}
+declare const Snippet: react.ForwardRefExoticComponent<SnippetProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ImageListProps extends HTMLAttributes<HTMLDivElement> {
+    /** Image items */
+    items?: ImageListItem[];
+    /** Number of columns */
+    cols?: number;
+    /** Gap between items */
+    gap?: number;
+    /** Row height */
+    rowHeight?: number | 'auto';
+    /** Variant */
+    variant?: 'standard' | 'masonry' | 'quilted' | 'woven';
+    /** On item click */
+    onItemClick?: (item: ImageListItem, index: number) => void;
+}
+declare const ImageList: react.ForwardRefExoticComponent<ImageListProps & react.RefAttributes<HTMLDivElement>>;
+interface ImageListItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Image source */
+    src?: string;
+    /** Alt text */
+    alt?: string;
+    /** Title */
+    title?: string;
+    /** Subtitle */
+    subtitle?: string;
+    /** Column span */
+    cols?: number;
+    /** Row span */
+    rows?: number;
+    /** Children (for custom content) */
+    children?: ReactNode;
+}
+interface ImageListItem {
+    src: string;
+    alt?: string;
+    title?: string;
+    subtitle?: string;
+    cols?: number;
+    rows?: number;
+}
+declare const ImageListItem: react.ForwardRefExoticComponent<ImageListItemProps & react.RefAttributes<HTMLDivElement>>;
+interface ImageListItemBarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Bar position */
+    position?: 'top' | 'bottom';
+    /** Action buttons */
+    actionIcon?: ReactNode;
+    /** Action position */
+    actionPosition?: 'left' | 'right';
+}
+declare const ImageListItemBar: react.ForwardRefExoticComponent<ImageListItemBarProps & react.RefAttributes<HTMLDivElement>>;
+
+interface AlertDialogProps extends HTMLAttributes<HTMLDivElement> {
+    /** Open state */
+    open?: boolean;
+    /** On open change */
+    onOpenChange?: (open: boolean) => void;
+}
+declare const AlertDialog: react.ForwardRefExoticComponent<AlertDialogProps & react.RefAttributes<HTMLDivElement>>;
+interface AlertDialogContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const AlertDialogContent: react.ForwardRefExoticComponent<AlertDialogContentProps & react.RefAttributes<HTMLDivElement>>;
+interface AlertDialogHeaderProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const AlertDialogHeader: react.ForwardRefExoticComponent<AlertDialogHeaderProps & react.RefAttributes<HTMLDivElement>>;
+interface AlertDialogTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+}
+declare const AlertDialogTitle: react.ForwardRefExoticComponent<AlertDialogTitleProps & react.RefAttributes<HTMLHeadingElement>>;
+interface AlertDialogDescriptionProps extends HTMLAttributes<HTMLParagraphElement> {
+}
+declare const AlertDialogDescription: react.ForwardRefExoticComponent<AlertDialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>>;
+interface AlertDialogFooterProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const AlertDialogFooter: react.ForwardRefExoticComponent<AlertDialogFooterProps & react.RefAttributes<HTMLDivElement>>;
+interface AlertDialogActionProps extends HTMLAttributes<HTMLButtonElement> {
+    /** Destructive action */
+    destructive?: boolean;
+}
+declare const AlertDialogAction: react.ForwardRefExoticComponent<AlertDialogActionProps & react.RefAttributes<HTMLButtonElement>>;
+interface AlertDialogCancelProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare const AlertDialogCancel: react.ForwardRefExoticComponent<AlertDialogCancelProps & react.RefAttributes<HTMLButtonElement>>;
+
+type MessageType = 'info' | 'success' | 'warning' | 'error' | 'loading';
+interface MessageProps extends Omit<HTMLAttributes<HTMLDivElement>, 'content'> {
+    /** Message type */
+    type?: MessageType;
+    /** Message content */
+    content: ReactNode;
+    /** Duration in ms (0 for manual close) */
+    duration?: number;
+    /** On close callback */
+    onClose?: () => void;
+    /** Show icon */
+    showIcon?: boolean;
+    /** Closable */
+    closable?: boolean;
+}
+declare const Message: react.ForwardRefExoticComponent<MessageProps & react.RefAttributes<HTMLDivElement>>;
+interface MessageContainerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Position */
+    position?: 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right';
+}
+declare const MessageContainer: react.ForwardRefExoticComponent<MessageContainerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CircularProgressProps extends HTMLAttributes<HTMLDivElement> {
+    /** Progress value (0-100) */
+    value?: number;
+    /** Size in pixels */
+    size?: number;
+    /** Stroke width */
+    strokeWidth?: number;
+    /** Indeterminate state */
+    indeterminate?: boolean;
+    /** Color */
+    color?: 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    /** Show value label */
+    showValue?: boolean;
+    /** Track color */
+    trackColor?: string;
+    /** Custom formatter */
+    formatValue?: (value: number) => string;
+}
+declare const CircularProgress: react.ForwardRefExoticComponent<CircularProgressProps & react.RefAttributes<HTMLDivElement>>;
+
+interface PopconfirmProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Title */
+    title: ReactNode;
+    /** Description */
+    description?: ReactNode;
+    /** Trigger element */
+    children: ReactNode;
+    /** On confirm callback */
+    onConfirm?: () => void;
+    /** On cancel callback */
+    onCancel?: () => void;
+    /** Confirm button text */
+    okText?: string;
+    /** Cancel button text */
+    cancelText?: string;
+    /** Placement */
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    /** Show icon */
+    showIcon?: boolean;
+    /** Icon */
+    icon?: ReactNode;
+    /** Disabled */
+    disabled?: boolean;
+    /** Ok button type */
+    okType?: 'primary' | 'danger';
+}
+declare const Popconfirm: react.ForwardRefExoticComponent<PopconfirmProps & react.RefAttributes<HTMLDivElement>>;
+
+interface WatermarkProps extends Omit<HTMLAttributes<HTMLDivElement>, 'content'> {
+    /** Watermark text */
+    content?: string | string[];
+    /** Font size */
+    fontSize?: number;
+    /** Font color */
+    fontColor?: string;
+    /** Font family */
+    fontFamily?: string;
+    /** Rotation angle */
+    rotate?: number;
+    /** Gap between watermarks */
+    gap?: [number, number];
+    /** Offset from origin */
+    offset?: [number, number];
+    /** Z-index */
+    zIndex?: number;
+    /** Image source (alternative to text) */
+    image?: string;
+    /** Image width */
+    imageWidth?: number;
+    /** Image height */
+    imageHeight?: number;
+}
+declare const Watermark: react.ForwardRefExoticComponent<WatermarkProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TourStep {
+    /** Target element selector or ref */
+    target: string | HTMLElement | null;
+    /** Step title */
+    title: ReactNode;
+    /** Step description */
+    description?: ReactNode;
+    /** Placement */
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    /** Cover image */
+    cover?: ReactNode;
+    /** Custom arrow style */
+    arrow?: boolean;
+}
+interface TourProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Tour steps */
+    steps: TourStep[];
+    /** Open state */
+    open?: boolean;
+    /** On open change */
+    onOpenChange?: (open: boolean) => void;
+    /** Current step index */
+    current?: number;
+    /** On step change */
+    onChange?: (current: number) => void;
+    /** On finish callback */
+    onFinish?: () => void;
+    /** Show mask */
+    mask?: boolean;
+    /** Arrow visibility */
+    arrow?: boolean;
+    /** Next button text */
+    nextText?: string;
+    /** Previous button text */
+    prevText?: string;
+    /** Finish button text */
+    finishText?: string;
+    /** Skip button text */
+    skipText?: string;
+    /** Show skip button */
+    showSkip?: boolean;
+}
+declare const Tour: react.ForwardRefExoticComponent<TourProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SheetProps extends HTMLAttributes<HTMLDivElement> {
+    /** Open state */
+    open?: boolean;
+    /** On open change */
+    onOpenChange?: (open: boolean) => void;
+    /** Side */
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    /** Close on overlay click */
+    closeOnOverlayClick?: boolean;
+}
+declare const Sheet: react.ForwardRefExoticComponent<SheetProps & react.RefAttributes<HTMLDivElement>>;
+interface SheetHeaderProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const SheetHeader: react.ForwardRefExoticComponent<SheetHeaderProps & react.RefAttributes<HTMLDivElement>>;
+interface SheetTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+}
+declare const SheetTitle: react.ForwardRefExoticComponent<SheetTitleProps & react.RefAttributes<HTMLHeadingElement>>;
+interface SheetDescriptionProps extends HTMLAttributes<HTMLParagraphElement> {
+}
+declare const SheetDescription: react.ForwardRefExoticComponent<SheetDescriptionProps & react.RefAttributes<HTMLParagraphElement>>;
+interface SheetContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const SheetContent: react.ForwardRefExoticComponent<SheetContentProps & react.RefAttributes<HTMLDivElement>>;
+interface SheetFooterProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const SheetFooter: react.ForwardRefExoticComponent<SheetFooterProps & react.RefAttributes<HTMLDivElement>>;
+interface SheetCloseProps extends HTMLAttributes<HTMLButtonElement> {
+    /** On close callback */
+    onClose?: () => void;
+}
+declare const SheetClose: react.ForwardRefExoticComponent<SheetCloseProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ConfigProviderProps {
+    /** Children */
+    children: ReactNode;
+    /** Theme mode */
+    theme?: 'light' | 'dark' | 'system';
+    /** Locale */
+    locale?: string;
+    /** Component size */
+    size?: 'small' | 'medium' | 'large';
+    /** Prefix for class names */
+    prefixCls?: string;
+    /** Direction */
+    direction?: 'ltr' | 'rtl';
+    /** Custom config */
+    config?: Record<string, unknown>;
+}
+interface ConfigContextValue {
+    theme: 'light' | 'dark' | 'system';
+    locale: string;
+    size: 'small' | 'medium' | 'large';
+    prefixCls: string;
+    direction: 'ltr' | 'rtl';
+    config: Record<string, unknown>;
+}
+declare const useConfig: () => ConfigContextValue;
+declare const ConfigProvider: {
+    ({ children, theme, locale, size, prefixCls, direction, config, }: ConfigProviderProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PortalProps {
+    /** Children to render in portal */
+    children: ReactNode;
+    /** Target container element or selector */
+    container?: HTMLElement | string | null;
+    /** Whether portal is disabled (render inline) */
+    disabled?: boolean;
+}
+declare const Portal: {
+    ({ children, container, disabled, }: PortalProps): react_jsx_runtime.JSX.Element | null;
+    displayName: string;
+};
+
+type TransitionType = 'fade' | 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right' | 'scale' | 'scale-y' | 'scale-x' | 'rotate' | 'flip' | 'collapse';
+interface TransitionProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Whether to show the element */
+    show: boolean;
+    /** Transition type */
+    type?: TransitionType;
+    /** Duration in milliseconds */
+    duration?: number;
+    /** Delay in milliseconds */
+    delay?: number;
+    /** Timing function */
+    timing?: 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out';
+    /** Whether to unmount when hidden */
+    unmountOnExit?: boolean;
+    /** Enter callback */
+    onEnter?: () => void;
+    /** Entered callback */
+    onEntered?: () => void;
+    /** Exit callback */
+    onExit?: () => void;
+    /** Exited callback */
+    onExited?: () => void;
+    /** Children */
+    children: ReactNode;
+}
+declare const Transition: react.ForwardRefExoticComponent<TransitionProps & react.RefAttributes<HTMLDivElement>>;
+
+interface AffixProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Offset from top when affixed */
+    offsetTop?: number;
+    /** Offset from bottom when affixed */
+    offsetBottom?: number;
+    /** Target container for scroll events */
+    target?: () => HTMLElement | Window | null;
+    /** Callback when affix state changes */
+    onChange?: (affixed: boolean) => void;
+    /** Children */
+    children: ReactNode;
+}
+declare const Affix: react.ForwardRefExoticComponent<AffixProps & react.RefAttributes<HTMLDivElement>>;
+
+interface FloatButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Icon to display */
+    icon?: ReactNode;
+    /** Tooltip text */
+    tooltip?: string;
+    /** Shape of the button */
+    shape?: 'circle' | 'square';
+    /** Button type/variant */
+    variant?: 'default' | 'primary';
+    /** Badge content */
+    badge?: ReactNode;
+    /** Position */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Href for link button */
+    href?: string;
+    /** Target for link */
+    target?: string;
+}
+declare const FloatButton: react__default.ForwardRefExoticComponent<FloatButtonProps & react__default.RefAttributes<HTMLButtonElement>>;
+interface FloatButtonGroupProps extends Omit<ButtonHTMLAttributes<HTMLDivElement>, 'onClick'> {
+    /** Trigger type */
+    trigger?: 'click' | 'hover';
+    /** Open state (controlled) */
+    open?: boolean;
+    /** On open change */
+    onOpenChange?: (open: boolean) => void;
+    /** Icon when closed */
+    icon?: ReactNode;
+    /** Icon when open */
+    closeIcon?: ReactNode;
+    /** Shape */
+    shape?: 'circle' | 'square';
+    /** Position */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Children (FloatButton items) */
+    children: ReactNode;
+}
+declare const FloatButtonGroup: react__default.ForwardRefExoticComponent<FloatButtonGroupProps & react__default.RefAttributes<HTMLDivElement>>;
+interface FloatBackTopProps extends Omit<FloatButtonProps, 'onClick' | 'target'> {
+    /** Visibility threshold (scroll distance) */
+    visibilityHeight?: number;
+    /** Target scroll container */
+    target?: () => HTMLElement | Window | null;
+    /** Duration of scroll animation */
+    duration?: number;
+    /** On click callback */
+    onClick?: () => void;
+}
+declare const FloatBackTop: react__default.ForwardRefExoticComponent<FloatBackTopProps & react__default.RefAttributes<HTMLButtonElement>>;
+
+type ResizeDirection = 'top' | 'bottom' | 'left' | 'right' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+interface ResizableProps extends HTMLAttributes<HTMLDivElement> {
+    /** Minimum width */
+    minWidth?: number;
+    /** Maximum width */
+    maxWidth?: number;
+    /** Minimum height */
+    minHeight?: number;
+    /** Maximum height */
+    maxHeight?: number;
+    /** Initial width */
+    defaultWidth?: number;
+    /** Initial height */
+    defaultHeight?: number;
+    /** Controlled width */
+    width?: number;
+    /** Controlled height */
+    height?: number;
+    /** Enabled resize directions */
+    directions?: ResizeDirection[];
+    /** Handle size */
+    handleSize?: number;
+    /** On resize callback */
+    onResize?: (width: number, height: number) => void;
+    /** On resize start */
+    onResizeStart?: () => void;
+    /** On resize end */
+    onResizeEnd?: (width: number, height: number) => void;
+    /** Children */
+    children: ReactNode;
+}
+declare const Resizable: react.ForwardRefExoticComponent<ResizableProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ToastProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Toast title */
+    title?: react__default.ReactNode;
+    /** Toast description/message */
+    description?: react__default.ReactNode;
+    /** Toast type */
+    type?: 'default' | 'success' | 'error' | 'warning' | 'info';
+    /** Duration in ms before auto-dismiss (0 = no auto-dismiss) */
+    duration?: number;
+    /** Show close button */
+    closable?: boolean;
+    /** Action button */
+    action?: react__default.ReactNode;
+    /** Called when toast is dismissed */
+    onDismiss?: () => void;
+    /** Toast position */
+    position?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+    /** Whether the toast is open */
+    open?: boolean;
+}
+declare const Toast: react__default.ForwardRefExoticComponent<ToastProps & react__default.RefAttributes<HTMLDivElement>>;
+interface ToastContainerProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Position of the toast container */
+    position?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+}
+declare const ToastContainer: react__default.ForwardRefExoticComponent<ToastContainerProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface DialogProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Whether the dialog is open */
+    open?: boolean;
+    /** Called when the dialog should close */
+    onOpenChange?: (open: boolean) => void;
+    /** Dialog title */
+    title?: react__default.ReactNode;
+    /** Dialog description */
+    description?: react__default.ReactNode;
+    /** Whether to show overlay */
+    overlay?: boolean;
+    /** Whether clicking overlay closes the dialog */
+    closeOnOverlayClick?: boolean;
+    /** Whether pressing Escape closes the dialog */
+    closeOnEscape?: boolean;
+    /** Whether to render in a portal */
+    portal?: boolean;
+    /** Dialog size */
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+}
+declare const Dialog: react__default.ForwardRefExoticComponent<DialogProps & react__default.RefAttributes<HTMLDivElement>>;
+interface DialogHeaderProps extends react__default.HTMLAttributes<HTMLDivElement> {
+}
+declare const DialogHeader: react__default.ForwardRefExoticComponent<DialogHeaderProps & react__default.RefAttributes<HTMLDivElement>>;
+interface DialogBodyProps extends react__default.HTMLAttributes<HTMLDivElement> {
+}
+declare const DialogBody: react__default.ForwardRefExoticComponent<DialogBodyProps & react__default.RefAttributes<HTMLDivElement>>;
+interface DialogFooterProps extends react__default.HTMLAttributes<HTMLDivElement> {
+}
+declare const DialogFooter: react__default.ForwardRefExoticComponent<DialogFooterProps & react__default.RefAttributes<HTMLDivElement>>;
+interface DialogCloseProps extends react__default.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const DialogClose: react__default.ForwardRefExoticComponent<DialogCloseProps & react__default.RefAttributes<HTMLButtonElement>>;
+
+interface LabelProps extends react__default.LabelHTMLAttributes<HTMLLabelElement> {
+    /** Whether the field is required */
+    required?: boolean;
+    /** Whether the label is disabled */
+    disabled?: boolean;
+    /** Size of the label */
+    size?: 'sm' | 'md' | 'lg';
+    /** Optional description text */
+    description?: react__default.ReactNode;
+    /** Whether to show optional indicator */
+    showOptional?: boolean;
+}
+declare const Label: react__default.ForwardRefExoticComponent<LabelProps & react__default.RefAttributes<HTMLLabelElement>>;
+
+interface SeparatorProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Orientation of the separator */
+    orientation?: 'horizontal' | 'vertical';
+    /** Whether the separator is decorative */
+    decorative?: boolean;
+    /** Size/thickness of the separator */
+    size?: 'sm' | 'md' | 'lg';
+    /** Label to show in the middle */
+    label?: react__default.ReactNode;
+    /** Label position */
+    labelPosition?: 'left' | 'center' | 'right';
+}
+declare const Separator: react__default.ForwardRefExoticComponent<SeparatorProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface HeadingProps extends react__default.HTMLAttributes<HTMLHeadingElement> {
+    /** Heading level (h1-h6) */
+    as?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+    /** Visual size (independent from semantic level) */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
+    /** Font weight */
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Whether to truncate text with ellipsis */
+    truncate?: boolean;
+    /** Color variant */
+    color?: 'default' | 'muted' | 'primary' | 'secondary' | 'success' | 'warning' | 'error';
+    /** Line height */
+    lineHeight?: 'tight' | 'normal' | 'relaxed';
+}
+declare const HeadingText: react__default.ForwardRefExoticComponent<HeadingProps & react__default.RefAttributes<HTMLHeadingElement>>;
+
+interface TextProps {
+    /** HTML element to render */
+    as?: 'p' | 'span' | 'div' | 'label' | 'small' | 'strong' | 'em';
+    /** Text size */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Font weight */
+    weight?: 'light' | 'normal' | 'medium' | 'semibold' | 'bold';
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right' | 'justify';
+    /** Whether to truncate text with ellipsis */
+    truncate?: boolean;
+    /** Number of lines before truncating (requires truncate) */
+    lineClamp?: number;
+    /** Color variant */
+    color?: 'default' | 'muted' | 'primary' | 'secondary' | 'success' | 'warning' | 'error';
+    /** Line height */
+    lineHeight?: 'tight' | 'normal' | 'relaxed' | 'loose';
+    /** Whether text is inline */
+    inline?: boolean;
+    /** Text transform */
+    transform?: 'uppercase' | 'lowercase' | 'capitalize' | 'none';
+    /** Whether to inherit parent styles */
+    inherit?: boolean;
+    /** Additional class name */
+    className?: string;
+    /** Inline styles */
+    style?: react__default.CSSProperties;
+    /** Children */
+    children?: react__default.ReactNode;
+}
+declare const TextBlock: react__default.ForwardRefExoticComponent<TextProps & react__default.HTMLAttributes<HTMLElement> & react__default.RefAttributes<HTMLElement>>;
+
+interface BoxProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** HTML element to render */
+    as?: react__default.ElementType;
+    /** Padding */
+    p?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Padding horizontal */
+    px?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Padding vertical */
+    py?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Margin */
+    m?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto';
+    /** Margin horizontal */
+    mx?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto';
+    /** Margin vertical */
+    my?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto';
+    /** Background color */
+    bg?: 'transparent' | 'primary' | 'secondary' | 'muted' | 'accent' | 'surface';
+    /** Border radius */
+    radius?: 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    /** Shadow */
+    shadow?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Display */
+    display?: 'block' | 'inline' | 'inline-block' | 'flex' | 'inline-flex' | 'grid' | 'none';
+    /** Width */
+    w?: 'auto' | 'full' | 'screen' | 'fit' | 'min' | 'max';
+    /** Height */
+    h?: 'auto' | 'full' | 'screen' | 'fit' | 'min' | 'max';
+    /** Border */
+    border?: boolean;
+}
+declare const Box: react__default.ForwardRefExoticComponent<BoxProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface CenterProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** HTML element to render */
+    as?: react__default.ElementType;
+    /** Whether to center inline (horizontal only) */
+    inline?: boolean;
+    /** Padding */
+    p?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Gap between children */
+    gap?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Direction of children */
+    direction?: 'row' | 'column';
+}
+declare const Center: react__default.ForwardRefExoticComponent<CenterProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface FileInputProps extends Omit<react__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'value' | 'onChange' | 'size'> {
+    /** Current file(s) */
+    value?: File | File[] | null;
+    /** Called when files change */
+    onChange?: (files: File | File[] | null) => void;
+    /** Whether to accept multiple files */
+    multiple?: boolean;
+    /** Accepted file types */
+    accept?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the input is in error state */
+    error?: boolean;
+    /** Whether to show clear button */
+    clearable?: boolean;
+    /** Label for the button */
+    buttonLabel?: string;
+    /** Variant style */
+    variant?: 'default' | 'filled' | 'unstyled';
+}
+declare const FileInput: react__default.ForwardRefExoticComponent<FileInputProps & react__default.RefAttributes<HTMLInputElement>>;
+
+interface RangeSliderProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** Current range value [min, max] */
+    value?: [number, number];
+    /** Default range value */
+    defaultValue?: [number, number];
+    /** Called when value changes */
+    onChange?: (value: [number, number]) => void;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Whether the slider is disabled */
+    disabled?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Color variant */
+    color?: 'primary' | 'secondary' | 'success' | 'warning' | 'error';
+    /** Show marks */
+    marks?: boolean | {
+        value: number;
+        label?: string;
+    }[];
+    /** Show tooltip with value */
+    showTooltip?: boolean;
+    /** Orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Minimum range between handles */
+    minRange?: number;
+    /** Label */
+    label?: react__default.ReactNode;
+}
+declare const RangeSlider: react__default.ForwardRefExoticComponent<RangeSliderProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface MultiSelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+}
+interface MultiSelectProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Available options */
+    options: MultiSelectOption[];
+    /** Selected values */
+    value?: string[];
+    /** Default selected values */
+    defaultValue?: string[];
+    /** Called when selection changes */
+    onChange?: (value: string[]) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the select is disabled */
+    disabled?: boolean;
+    /** Whether the select is searchable */
+    searchable?: boolean;
+    /** Whether to allow clearing all selections */
+    clearable?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Maximum number of selections */
+    maxSelections?: number;
+    /** Label */
+    label?: react__default.ReactNode;
+    /** Whether to show checkboxes */
+    withCheckbox?: boolean;
+    /** Hide selected options from dropdown */
+    hideSelected?: boolean;
+}
+declare const MultiSelect: react__default.ForwardRefExoticComponent<MultiSelectProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    description?: string;
+}
+interface ComboboxProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Available options */
+    options: ComboboxOption[];
+    /** Selected value */
+    value?: string;
+    /** Default value */
+    defaultValue?: string;
+    /** Called when selection changes */
+    onChange?: (value: string) => void;
+    /** Called when input value changes */
+    onInputChange?: (value: string) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the combobox is disabled */
+    disabled?: boolean;
+    /** Whether to allow custom values */
+    allowCustomValue?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Label */
+    label?: react__default.ReactNode;
+    /** Whether selection is required */
+    required?: boolean;
+    /** Empty state message */
+    emptyMessage?: string;
+    /** Loading state */
+    loading?: boolean;
+}
+declare const Combobox: react__default.ForwardRefExoticComponent<ComboboxProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface ColorInputProps extends Omit<react__default.InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'size'> {
+    /** Current color value (hex) */
+    value?: string;
+    /** Default color value */
+    defaultValue?: string;
+    /** Called when color changes */
+    onChange?: (value: string) => void;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Whether the input is disabled */
+    disabled?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Label */
+    label?: react__default.ReactNode;
+    /** Preset colors to show */
+    swatches?: string[];
+    /** Whether to show the color picker popup */
+    withPicker?: boolean;
+    /** Format for the color value */
+    format?: 'hex' | 'rgb' | 'hsl';
+    /** Whether to allow opacity/alpha */
+    withAlpha?: boolean;
+}
+declare const ColorInput: react__default.ForwardRefExoticComponent<ColorInputProps & react__default.RefAttributes<HTMLInputElement>>;
+
+interface CopyButtonProps extends Omit<react__default.ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'onError'> {
+    /** Value to copy to clipboard */
+    value: string;
+    /** Timeout in ms before resetting to default state */
+    timeout?: number;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Variant style */
+    variant?: 'default' | 'filled' | 'outline' | 'subtle';
+    /** Color variant */
+    color?: 'default' | 'primary' | 'secondary';
+    /** Called after copying */
+    onCopy?: () => void;
+    /** Called on copy error */
+    onError?: (error: Error) => void;
+    /** Custom children (receives copied state) */
+    children?: (props: {
+        copied: boolean;
+        copy: () => void;
+    }) => react__default.ReactNode;
+    /** Copy icon/label */
+    copyLabel?: react__default.ReactNode;
+    /** Copied icon/label */
+    copiedLabel?: react__default.ReactNode;
+}
+declare const CopyButton: react__default.ForwardRefExoticComponent<CopyButtonProps & react__default.RefAttributes<HTMLButtonElement>>;
+
+interface CheckboxGroupOption {
+    value: string;
+    label: react__default.ReactNode;
+    disabled?: boolean;
+    description?: string;
+}
+interface CheckboxGroupContextValue {
+    value: string[];
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    name?: string;
+}
+declare const useCheckboxGroup: () => CheckboxGroupContextValue | null;
+interface CheckboxGroupProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Current selected values */
+    value?: string[];
+    /** Default selected values */
+    defaultValue?: string[];
+    /** Called when selection changes */
+    onChange?: (value: string[]) => void;
+    /** Options to render */
+    options?: CheckboxGroupOption[];
+    /** Whether the group is disabled */
+    disabled?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Layout orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Name for form submission */
+    name?: string;
+    /** Label for the group */
+    label?: react__default.ReactNode;
+    /** Whether selection is required */
+    required?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Error message */
+    errorMessage?: react__default.ReactNode;
+    /** Gap between items */
+    gap?: 'xs' | 'sm' | 'md' | 'lg';
+}
+declare const CheckboxGroup: react__default.ForwardRefExoticComponent<CheckboxGroupProps & react__default.RefAttributes<HTMLDivElement>>;
+interface CheckboxGroupItemProps extends Omit<react__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'onChange'> {
+    /** Item value */
+    value: string;
+    /** Item label */
+    label?: react__default.ReactNode;
+    /** Item description */
+    description?: react__default.ReactNode;
+}
+declare const CheckboxGroupItem: react__default.ForwardRefExoticComponent<CheckboxGroupItemProps & react__default.RefAttributes<HTMLInputElement>>;
+
+interface AppShellContextValue {
+    navbarCollapsed: boolean;
+    asideCollapsed: boolean;
+    toggleNavbar: () => void;
+    toggleAside: () => void;
+}
+declare const useAppShell: () => AppShellContextValue;
+interface AppShellProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Header height */
+    headerHeight?: number | string;
+    /** Footer height */
+    footerHeight?: number | string;
+    /** Navbar width */
+    navbarWidth?: number | string;
+    /** Aside width */
+    asideWidth?: number | string;
+    /** Whether navbar is initially collapsed */
+    navbarCollapsed?: boolean;
+    /** Whether aside is initially collapsed */
+    asideCollapsed?: boolean;
+    /** Padding for main content */
+    padding?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Layout variant */
+    layout?: 'default' | 'alt';
+    /** Whether header is fixed */
+    fixedHeader?: boolean;
+}
+declare const AppShell: react__default.ForwardRefExoticComponent<AppShellProps & react__default.RefAttributes<HTMLDivElement>>;
+interface AppShellHeaderProps extends react__default.HTMLAttributes<HTMLElement> {
+}
+declare const AppShellHeader: react__default.ForwardRefExoticComponent<AppShellHeaderProps & react__default.RefAttributes<HTMLElement>>;
+interface AppShellNavbarProps extends react__default.HTMLAttributes<HTMLElement> {
+    /** Collapsed width */
+    collapsedWidth?: number | string;
+}
+declare const AppShellNavbar: react__default.ForwardRefExoticComponent<AppShellNavbarProps & react__default.RefAttributes<HTMLElement>>;
+interface AppShellMainProps extends react__default.HTMLAttributes<HTMLElement> {
+}
+declare const AppShellMain: react__default.ForwardRefExoticComponent<AppShellMainProps & react__default.RefAttributes<HTMLElement>>;
+interface AppShellAsideProps extends react__default.HTMLAttributes<HTMLElement> {
+}
+declare const AppShellAside: react__default.ForwardRefExoticComponent<AppShellAsideProps & react__default.RefAttributes<HTMLElement>>;
+interface AppShellFooterProps extends react__default.HTMLAttributes<HTMLElement> {
+}
+declare const AppShellFooter: react__default.ForwardRefExoticComponent<AppShellFooterProps & react__default.RefAttributes<HTMLElement>>;
+
+interface AppBarProps extends react__default.HTMLAttributes<HTMLElement> {
+    /** Position of the app bar */
+    position?: 'fixed' | 'absolute' | 'sticky' | 'static' | 'relative';
+    /** Color variant */
+    color?: 'default' | 'primary' | 'secondary' | 'transparent';
+    /** Whether to show elevation/shadow */
+    elevation?: boolean;
+    /** Whether the app bar is dense */
+    dense?: boolean;
+}
+declare const AppBar: react__default.ForwardRefExoticComponent<AppBarProps & react__default.RefAttributes<HTMLElement>>;
+interface AppBarToolbarProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Whether toolbar content should be centered */
+    centered?: boolean;
+    /** Whether the toolbar is dense */
+    dense?: boolean;
+    /** Disable gutters (horizontal padding) */
+    disableGutters?: boolean;
+}
+declare const AppBarToolbar: react__default.ForwardRefExoticComponent<AppBarToolbarProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface PaperProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** HTML element to render */
+    as?: react__default.ElementType;
+    /** Elevation level (shadow depth) */
+    elevation?: 0 | 1 | 2 | 3 | 4 | 5;
+    /** Whether to use square corners */
+    square?: boolean;
+    /** Border radius size */
+    radius?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Variant style */
+    variant?: 'elevation' | 'outlined' | 'filled';
+    /** Padding */
+    p?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Whether paper is interactive (hoverable) */
+    interactive?: boolean;
+    /** Background color */
+    bg?: 'default' | 'muted' | 'subtle';
+}
+declare const Paper: react__default.ForwardRefExoticComponent<PaperProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface BackdropProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Whether the backdrop is visible */
+    open?: boolean;
+    /** Called when backdrop is clicked */
+    onClick?: (event: react__default.MouseEvent<HTMLDivElement>) => void;
+    /** Whether the backdrop is invisible */
+    invisible?: boolean;
+    /** Z-index of the backdrop */
+    zIndex?: number;
+    /** Whether to use portal */
+    portal?: boolean;
+    /** Whether to lock body scroll */
+    lockScroll?: boolean;
+    /** Transition duration in ms */
+    transitionDuration?: number;
+}
+declare const Backdrop: react__default.ForwardRefExoticComponent<BackdropProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface LoadingOverlayProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Whether the overlay is visible */
+    visible?: boolean;
+    /** Z-index of the overlay */
+    zIndex?: number;
+    /** Overlay background opacity */
+    overlayOpacity?: number;
+    /** Overlay background blur */
+    blur?: number;
+    /** Custom loader element */
+    loader?: react__default.ReactNode;
+    /** Loading text */
+    loaderText?: react__default.ReactNode;
+    /** Loader size */
+    loaderSize?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Transition duration in ms */
+    transitionDuration?: number;
+    /** Whether the overlay covers the entire viewport */
+    fullscreen?: boolean;
+}
+declare const LoadingOverlay: react__default.ForwardRefExoticComponent<LoadingOverlayProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface RingProgressSection {
+    value: number;
+    color: string;
+    tooltip?: string;
+}
+interface RingProgressProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Progress value (0-100) or sections */
+    value?: number;
+    /** Multiple sections */
+    sections?: RingProgressSection[];
+    /** Size of the ring */
+    size?: number;
+    /** Thickness of the ring */
+    thickness?: number;
+    /** Round end caps */
+    roundCaps?: boolean;
+    /** Label in the center */
+    label?: react__default.ReactNode;
+    /** Root color (background ring) */
+    rootColor?: string;
+    /** Progress color (single value) */
+    color?: string;
+}
+declare const RingProgress: react__default.ForwardRefExoticComponent<RingProgressProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface VisuallyHiddenProps extends react__default.HTMLAttributes<HTMLSpanElement> {
+    /** HTML element to render */
+    as?: react__default.ElementType;
+    /** Whether to make content focusable (shows on focus) */
+    focusable?: boolean;
+}
+declare const VisuallyHidden: react__default.ForwardRefExoticComponent<VisuallyHiddenProps & react__default.RefAttributes<HTMLSpanElement>>;
+declare const visuallyHiddenStyles: react__default.CSSProperties;
+
+interface FocusTrapProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Whether the focus trap is active */
+    active?: boolean;
+    /** Whether to focus the first element on mount */
+    autoFocus?: boolean;
+    /** Whether to return focus on unmount */
+    returnFocus?: boolean;
+    /** Called when escape is pressed */
+    onEscape?: () => void;
+    /** Initial focus element selector or ref */
+    initialFocus?: string | react__default.RefObject<HTMLElement>;
+    /** Final focus element (for return focus) */
+    finalFocus?: react__default.RefObject<HTMLElement>;
+}
+declare const FocusTrap: react__default.ForwardRefExoticComponent<FocusTrapProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface HighlightProps extends react__default.HTMLAttributes<HTMLSpanElement> {
+    /** Text to highlight within */
+    children: string;
+    /** Query string or array of strings to highlight */
+    highlight: string | string[];
+    /** Color of the highlight */
+    color?: 'yellow' | 'green' | 'blue' | 'red' | 'purple' | 'orange';
+    /** Whether the highlight should be case sensitive */
+    caseSensitive?: boolean;
+    /** Custom highlight component */
+    highlightComponent?: react__default.ElementType;
+    /** Props to pass to highlight element */
+    highlightProps?: react__default.HTMLAttributes<HTMLElement>;
+}
+declare const Highlight: react__default.ForwardRefExoticComponent<HighlightProps & react__default.RefAttributes<HTMLSpanElement>>;
+
+interface IndicatorProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Position of the indicator */
+    position?: 'top-start' | 'top-center' | 'top-end' | 'middle-start' | 'middle-center' | 'middle-end' | 'bottom-start' | 'bottom-center' | 'bottom-end';
+    /** Color of the indicator */
+    color?: 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gray';
+    /** Size of the indicator */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Offset from the corner */
+    offset?: number;
+    /** Whether to show the indicator */
+    disabled?: boolean;
+    /** Whether to show a processing animation */
+    processing?: boolean;
+    /** Whether the indicator has a border */
+    withBorder?: boolean;
+    /** Label to show in the indicator */
+    label?: react__default.ReactNode;
+    /** Inline mode (no absolute positioning) */
+    inline?: boolean;
+    /** Z-index of the indicator */
+    zIndex?: number;
+}
+declare const Indicator: react__default.ForwardRefExoticComponent<IndicatorProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface SpoilerProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Maximum height when collapsed */
+    maxHeight?: number;
+    /** Label for show more button */
+    showLabel?: react__default.ReactNode;
+    /** Label for show less button */
+    hideLabel?: react__default.ReactNode;
+    /** Whether to hide the control button */
+    hideControls?: boolean;
+    /** Initial expanded state */
+    initialExpanded?: boolean;
+    /** Controlled expanded state */
+    expanded?: boolean;
+    /** Called when expanded state changes */
+    onExpandedChange?: (expanded: boolean) => void;
+    /** Transition duration in ms */
+    transitionDuration?: number;
+}
+declare const Spoiler: react__default.ForwardRefExoticComponent<SpoilerProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface StepperContextValue {
+    activeStep: number;
+    orientation: 'horizontal' | 'vertical';
+    size: 'sm' | 'md' | 'lg';
+    color: 'primary' | 'secondary' | 'success';
+}
+declare const useStepper: () => StepperContextValue;
+interface StepperProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Current active step (0-indexed) */
+    activeStep?: number;
+    /** Called when step changes */
+    onStepChange?: (step: number) => void;
+    /** Orientation of the stepper */
+    orientation?: 'horizontal' | 'vertical';
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Color variant */
+    color?: 'primary' | 'secondary' | 'success';
+    /** Whether to allow clicking on steps */
+    allowStepClick?: boolean;
+    /** Whether to show step numbers */
+    showStepNumbers?: boolean;
+    /** Icon for completed steps */
+    completedIcon?: react__default.ReactNode;
+}
+declare const Stepper: react__default.ForwardRefExoticComponent<StepperProps & react__default.RefAttributes<HTMLDivElement>>;
+interface StepperStepProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Step label */
+    label?: react__default.ReactNode;
+    /** Step description */
+    description?: react__default.ReactNode;
+    /** Optional icon */
+    icon?: react__default.ReactNode;
+    /** Whether step has an error */
+    error?: boolean;
+    /** Whether step is loading */
+    loading?: boolean;
+}
+declare const StepperStep: react__default.ForwardRefExoticComponent<StepperStepProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface NavLinkProps extends react__default.AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Whether the link is active */
+    active?: boolean;
+    /** Label for the link */
+    label?: react__default.ReactNode;
+    /** Description text */
+    description?: react__default.ReactNode;
+    /** Left section (icon) */
+    leftSection?: react__default.ReactNode;
+    /** Right section (badge, arrow) */
+    rightSection?: react__default.ReactNode;
+    /** Whether the link is disabled */
+    disabled?: boolean;
+    /** Variant style */
+    variant?: 'light' | 'filled' | 'subtle';
+    /** Color when active */
+    color?: 'primary' | 'secondary' | 'gray';
+    /** Whether to show active indicator */
+    noActiveIndicator?: boolean;
+    /** Nested nav links */
+    children?: react__default.ReactNode;
+    /** Whether the nested links are open */
+    opened?: boolean;
+    /** Called when clicked */
+    onClick?: (event: react__default.MouseEvent<HTMLAnchorElement>) => void;
+    /** Component to render as */
+    as?: react__default.ElementType;
+}
+declare const NavLink: react__default.ForwardRefExoticComponent<NavLinkProps & react__default.RefAttributes<HTMLAnchorElement>>;
+
+interface ChartDataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+interface ChartProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Chart data */
+    data: ChartDataPoint[];
+    /** Chart type */
+    type?: 'bar' | 'line' | 'pie' | 'donut';
+    /** Chart height */
+    height?: number;
+    /** Chart width */
+    width?: number | string;
+    /** Whether to show labels */
+    showLabels?: boolean;
+    /** Whether to show values */
+    showValues?: boolean;
+    /** Whether to show legend */
+    showLegend?: boolean;
+    /** Whether to show grid lines */
+    showGrid?: boolean;
+    /** Color palette */
+    colors?: string[];
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Whether chart is loading */
+    loading?: boolean;
+    /** Empty state message */
+    emptyMessage?: string;
+}
+declare const Chart: react__default.ForwardRefExoticComponent<ChartProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface JsonInputProps extends Omit<react__default.TextareaHTMLAttributes<HTMLTextAreaElement>, 'value' | 'onChange'> {
+    /** Current JSON value */
+    value?: string;
+    /** Default JSON value */
+    defaultValue?: string;
+    /** Called when value changes */
+    onChange?: (value: string) => void;
+    /** Called when JSON is valid/invalid */
+    onValidationChange?: (isValid: boolean, error?: string) => void;
+    /** Whether to validate on change */
+    validateOnChange?: boolean;
+    /** Whether to format on blur */
+    formatOnBlur?: boolean;
+    /** Indentation spaces */
+    indentation?: number;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Minimum rows */
+    minRows?: number;
+    /** Maximum rows */
+    maxRows?: number;
+    /** Label */
+    label?: react__default.ReactNode;
+    /** Error message */
+    error?: react__default.ReactNode;
+    /** Whether to show line numbers */
+    showLineNumbers?: boolean;
+}
+declare const JsonInput: react__default.ForwardRefExoticComponent<JsonInputProps & react__default.RefAttributes<HTMLTextAreaElement>>;
+
+interface AngleSliderProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Current angle value (0-360) */
+    value?: number;
+    /** Default angle value */
+    defaultValue?: number;
+    /** Called when angle changes */
+    onChange?: (value: number) => void;
+    /** Size of the slider */
+    size?: number;
+    /** Whether the slider is disabled */
+    disabled?: boolean;
+    /** Step increment */
+    step?: number;
+    /** Color of the track */
+    trackColor?: string;
+    /** Color of the thumb */
+    thumbColor?: string;
+    /** Whether to show the value label */
+    showValue?: boolean;
+    /** Format function for the value */
+    formatValue?: (value: number) => string;
+    /** Label */
+    label?: react__default.ReactNode;
+}
+declare const AngleSlider: react__default.ForwardRefExoticComponent<AngleSliderProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface TableOfContentsItem {
+    id: string;
+    label: string;
+    level: number;
+    children?: TableOfContentsItem[];
+}
+interface TableOfContentsProps extends react__default.HTMLAttributes<HTMLElement> {
+    /** Items to display */
+    items?: TableOfContentsItem[];
+    /** Active item ID */
+    activeId?: string;
+    /** Called when item is clicked */
+    onItemClick?: (id: string) => void;
+    /** Whether to highlight based on scroll position */
+    highlightOnScroll?: boolean;
+    /** Selector for heading elements to auto-generate items */
+    headingSelector?: string;
+    /** Offset for scroll spy */
+    scrollOffset?: number;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Maximum heading level to include */
+    maxLevel?: number;
+    /** Whether to show line connector */
+    withLine?: boolean;
+    /** Label for the TOC */
+    label?: react__default.ReactNode;
+}
+declare const TableOfContents: react__default.ForwardRefExoticComponent<TableOfContentsProps & react__default.RefAttributes<HTMLElement>>;
+
+interface SemiCircleProgressProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Progress value (0-100) */
+    value?: number;
+    /** Size of the component */
+    size?: number;
+    /** Thickness of the progress arc */
+    thickness?: number;
+    /** Color of the progress */
+    color?: string;
+    /** Color of the track */
+    trackColor?: string;
+    /** Label to show */
+    label?: react__default.ReactNode;
+    /** Whether to show percentage */
+    showPercentage?: boolean;
+    /** Format function for percentage */
+    formatPercentage?: (value: number) => string;
+    /** Orientation */
+    orientation?: 'up' | 'down';
+    /** Whether to animate */
+    animate?: boolean;
+}
+declare const SemiCircleProgress: react__default.ForwardRefExoticComponent<SemiCircleProgressProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface CheckboxCardProps extends Omit<react__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    /** Card label/title */
+    label?: react__default.ReactNode;
+    /** Card description */
+    description?: react__default.ReactNode;
+    /** Icon or image to display */
+    icon?: react__default.ReactNode;
+    /** Whether the card is checked */
+    checked?: boolean;
+    /** Default checked state */
+    defaultChecked?: boolean;
+    /** Called when checked state changes */
+    onChange?: (event: react__default.ChangeEvent<HTMLInputElement>) => void;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Whether the checkbox is inside or overlaid */
+    checkboxPosition?: 'top-start' | 'top-end' | 'hidden';
+    /** Whether to show as radio instead of checkbox */
+    radio?: boolean;
+    /** Border radius */
+    radius?: 'sm' | 'md' | 'lg';
+}
+declare const CheckboxCard: react__default.ForwardRefExoticComponent<CheckboxCardProps & react__default.RefAttributes<HTMLInputElement>>;
+
+interface ScrollShadowProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Orientation of scroll */
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    /** Shadow size */
+    shadowSize?: number;
+    /** Shadow color */
+    shadowColor?: string;
+    /** Whether to hide scrollbar */
+    hideScrollbar?: boolean;
+    /** Offset before showing shadow */
+    offset?: number;
+}
+declare const ScrollShadow: react__default.ForwardRefExoticComponent<ScrollShadowProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface ColorSwatchProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Color to display */
+    color: string;
+    /** Size of the swatch */
+    size?: number | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Border radius */
+    radius?: 'none' | 'sm' | 'md' | 'lg' | 'full';
+    /** Whether to show a border */
+    withShadow?: boolean;
+    /** Whether the swatch is selected */
+    selected?: boolean;
+    /** Children to render inside (e.g., checkmark) */
+    children?: react__default.ReactNode;
+}
+declare const ColorSwatch: react__default.ForwardRefExoticComponent<ColorSwatchProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface ThemeIconProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    /** Size of the icon container */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+    /** Border radius */
+    radius?: 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    /** Color variant */
+    color?: 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gray';
+    /** Variant style */
+    variant?: 'filled' | 'light' | 'outline' | 'gradient';
+    /** Gradient (when variant is gradient) */
+    gradient?: {
+        from: string;
+        to: string;
+        deg?: number;
+    };
+    /** Custom background color */
+    bg?: string;
+    /** Custom icon color */
+    iconColor?: string;
+}
+declare const ThemeIcon: react__default.ForwardRefExoticComponent<ThemeIconProps & react__default.RefAttributes<HTMLDivElement>>;
+
+interface DateTimePickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'size'> {
+    /** Selected date and time */
+    value?: Date | null;
+    /** On change callback */
+    onChange?: (date: Date | null) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Date format */
+    format?: string;
+    /** Minimum date */
+    minDate?: Date;
+    /** Maximum date */
+    maxDate?: Date;
+    /** Clearable */
+    clearable?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Time step in minutes */
+    timeStep?: number;
+    /** 12 or 24 hour format */
+    hourFormat?: '12' | '24';
+}
+declare const DateTimePicker: react.ForwardRefExoticComponent<DateTimePickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface MonthPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'size'> {
+    /** Selected month (0-11) and year */
+    value?: {
+        month: number;
+        year: number;
+    } | null;
+    /** On change callback */
+    onChange?: (value: {
+        month: number;
+        year: number;
+    } | null) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Format for display */
+    format?: 'short' | 'long';
+    /** Minimum year */
+    minYear?: number;
+    /** Maximum year */
+    maxYear?: number;
+    /** Clearable */
+    clearable?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+}
+declare const MonthPicker: react.ForwardRefExoticComponent<MonthPickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface YearPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'size'> {
+    /** Selected year */
+    value?: number | null;
+    /** On change callback */
+    onChange?: (year: number | null) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Minimum year */
+    minYear?: number;
+    /** Maximum year */
+    maxYear?: number;
+    /** Clearable */
+    clearable?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Error state */
+    error?: boolean;
+    /** Number of years to show per page */
+    yearsPerPage?: number;
+}
+declare const YearPicker: react.ForwardRefExoticComponent<YearPickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface RadioCardGroupContextValue {
+    name?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+interface RadioCardGroupProps {
+    /** Children */
+    children: ReactNode;
+    /** Group name */
+    name?: string;
+    /** Selected value */
+    value?: string;
+    /** Default value */
+    defaultValue?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Layout direction */
+    direction?: 'horizontal' | 'vertical';
+    /** Number of columns (when horizontal) */
+    columns?: number;
+    /** Gap between cards */
+    gap?: 'sm' | 'md' | 'lg';
+    /** Class name */
+    className?: string;
+}
+declare const RadioCardGroup: {
+    ({ children, name, value, onChange, disabled, size, direction, columns, gap, className, }: RadioCardGroupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface RadioCardProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'title'> {
+    /** Card title */
+    title?: ReactNode;
+    /** Card description */
+    description?: ReactNode;
+    /** Card icon */
+    icon?: ReactNode;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** With border */
+    withBorder?: boolean;
+    /** With check indicator */
+    withIndicator?: boolean;
+    /** Custom content */
+    children?: ReactNode;
+}
+declare const RadioCard: react.ForwardRefExoticComponent<RadioCardProps & react.RefAttributes<HTMLInputElement>>;
+declare const useRadioCardGroup: () => RadioCardGroupContextValue;
+
+interface ToolbarContextValue {
+    orientation?: 'horizontal' | 'vertical';
+    size?: 'sm' | 'md' | 'lg';
+}
+interface ToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Aria label */
+    'aria-label'?: string;
+}
+declare const Toolbar: react.ForwardRefExoticComponent<ToolbarProps & react.RefAttributes<HTMLDivElement>>;
+interface ToolbarButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Is active/pressed */
+    isActive?: boolean;
+    /** Variant */
+    variant?: 'default' | 'ghost' | 'outline';
+    /** Tooltip text */
+    tooltip?: string;
+}
+declare const ToolbarButton: react.ForwardRefExoticComponent<ToolbarButtonProps & react.RefAttributes<HTMLButtonElement>>;
+interface ToolbarSeparatorProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const ToolbarSeparator: react.ForwardRefExoticComponent<ToolbarSeparatorProps & react.RefAttributes<HTMLDivElement>>;
+interface ToolbarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Spacing between items */
+    spacing?: 'none' | 'sm' | 'md';
+}
+declare const ToolbarGroup: react.ForwardRefExoticComponent<ToolbarGroupProps & react.RefAttributes<HTMLDivElement>>;
+interface ToolbarToggleGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Type of selection */
+    type?: 'single' | 'multiple';
+    /** Selected value(s) */
+    value?: string | string[];
+    /** On value change */
+    onValueChange?: (value: string | string[]) => void;
+}
+declare const ToolbarToggleGroup: react.ForwardRefExoticComponent<ToolbarToggleGroupProps & react.RefAttributes<HTMLDivElement>>;
+interface ToolbarLinkProps extends HTMLAttributes<HTMLAnchorElement> {
+    /** Link href */
+    href?: string;
+    /** Target */
+    target?: string;
+}
+declare const ToolbarLink: react.ForwardRefExoticComponent<ToolbarLinkProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const useToolbar: () => ToolbarContextValue;
+
+type ResponsiveValue<T> = T | {
+    base?: T;
+    sm?: T;
+    md?: T;
+    lg?: T;
+    xl?: T;
+    '2xl'?: T;
+};
+interface SimpleGridProps extends HTMLAttributes<HTMLDivElement> {
+    /** Number of columns */
+    cols?: ResponsiveValue<number>;
+    /** Minimum child width (auto-fit) */
+    minChildWidth?: string;
+    /** Gap between items */
+    spacing?: ResponsiveValue<string | number>;
+    /** Horizontal spacing */
+    spacingX?: ResponsiveValue<string | number>;
+    /** Vertical spacing */
+    spacingY?: ResponsiveValue<string | number>;
+}
+declare const SimpleGrid: react.ForwardRefExoticComponent<SimpleGridProps & react.RefAttributes<HTMLDivElement>>;
+
+interface BlockquoteProps extends HTMLAttributes<HTMLQuoteElement> {
+    /** Quote citation/source */
+    cite?: string;
+    /** Author name */
+    author?: ReactNode;
+    /** Author title/role */
+    authorTitle?: ReactNode;
+    /** Author avatar */
+    avatar?: ReactNode;
+    /** Color variant */
+    color?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'error';
+    /** Border position */
+    borderPosition?: 'left' | 'top' | 'none';
+    /** Icon to show */
+    icon?: ReactNode;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** With background */
+    withBackground?: boolean;
+}
+declare const Blockquote: react.ForwardRefExoticComponent<BlockquoteProps & react.RefAttributes<HTMLQuoteElement>>;
+
+interface VirtualListProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onScroll'> {
+    /** Data items to render */
+    data: T[];
+    /** Height of each item (or function for variable heights) */
+    itemHeight: number | ((index: number, item: T) => number);
+    /** Container height */
+    height: number | string;
+    /** Width of the container */
+    width?: number | string;
+    /** Render function for each item */
+    renderItem: (item: T, index: number, style: CSSProperties) => ReactNode;
+    /** Number of items to overscan */
+    overscan?: number;
+    /** On scroll callback with scroll position */
+    onScrollChange?: (scrollTop: number) => void;
+    /** Key extractor */
+    getKey?: (item: T, index: number) => string | number;
+    /** Loading state */
+    loading?: boolean;
+    /** Loading component */
+    loadingComponent?: ReactNode;
+    /** Empty state component */
+    emptyComponent?: ReactNode;
+    /** Gap between items */
+    gap?: number;
+    /** Scroll to index */
+    scrollToIndex?: number;
+}
+declare const VirtualList: <T>(props: VirtualListProps<T> & {
+    ref?: React.ForwardedRef<HTMLDivElement>;
+}) => JSX.Element;
+
+interface InfiniteScrollProps extends HTMLAttributes<HTMLDivElement> {
+    /** Children to render */
+    children: ReactNode;
+    /** Callback when more items should be loaded */
+    onLoadMore: () => void | Promise<void>;
+    /** Whether there are more items to load */
+    hasMore: boolean;
+    /** Whether currently loading */
+    loading?: boolean;
+    /** Loading indicator component */
+    loader?: ReactNode;
+    /** End message when no more items */
+    endMessage?: ReactNode;
+    /** Threshold in pixels before triggering load */
+    threshold?: number;
+    /** Scroll direction */
+    direction?: 'down' | 'up';
+    /** Use window scroll instead of container */
+    useWindow?: boolean;
+    /** Inverse scroll (for chat-like interfaces) */
+    inverse?: boolean;
+    /** Initial load */
+    initialLoad?: boolean;
+    /** Scroll container height */
+    height?: number | string;
+}
+declare const InfiniteScroll: react.ForwardRefExoticComponent<InfiniteScrollProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SplitButtonOption {
+    /** Option label */
+    label: ReactNode;
+    /** Option value */
+    value: string;
+    /** Option icon */
+    icon?: ReactNode;
+    /** Disabled state */
+    disabled?: boolean;
+    /** On click handler */
+    onClick?: () => void;
+}
+interface SplitButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onClick' | 'onSelect'> {
+    /** Button variant */
+    variant?: 'primary' | 'secondary' | 'outline' | 'ghost' | 'danger';
+    /** Button size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Primary button content */
+    children: ReactNode;
+    /** Primary button click handler */
+    onClick?: () => void;
+    /** Dropdown options */
+    options: SplitButtonOption[];
+    /** Selected option value */
+    selectedValue?: string;
+    /** On option select */
+    onSelect?: (value: string) => void;
+    /** Loading state */
+    loading?: boolean;
+    /** Dropdown placement */
+    placement?: 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+    /** Icon for dropdown trigger */
+    dropdownIcon?: ReactNode;
+}
+declare const SplitButton: react.ForwardRefExoticComponent<SplitButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface NumberFormatterProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    /** Number value to format */
+    value: number;
+    /** Number of decimal places */
+    decimalPlaces?: number;
+    /** Locale for formatting */
+    locale?: string;
+    /** Format style */
+    formatStyle?: 'decimal' | 'currency' | 'percent' | 'unit';
+    /** Currency code (for currency style) */
+    currency?: string;
+    /** Currency display type */
+    currencyDisplay?: 'symbol' | 'narrowSymbol' | 'code' | 'name';
+    /** Unit type (for unit style) */
+    unit?: string;
+    /** Unit display type */
+    unitDisplay?: 'short' | 'long' | 'narrow';
+    /** Notation style */
+    notation?: 'standard' | 'scientific' | 'engineering' | 'compact';
+    /** Compact display */
+    compactDisplay?: 'short' | 'long';
+    /** Sign display */
+    signDisplay?: 'auto' | 'never' | 'always' | 'exceptZero';
+    /** Use grouping separators */
+    useGrouping?: boolean;
+    /** Prefix text */
+    prefix?: string;
+    /** Suffix text */
+    suffix?: string;
+    /** Minimum integer digits */
+    minimumIntegerDigits?: number;
+    /** Minimum fraction digits */
+    minimumFractionDigits?: number;
+    /** Maximum fraction digits */
+    maximumFractionDigits?: number;
+    /** Minimum significant digits */
+    minimumSignificantDigits?: number;
+    /** Maximum significant digits */
+    maximumSignificantDigits?: number;
+}
+declare const NumberFormatter: react.ForwardRefExoticComponent<NumberFormatterProps & react.RefAttributes<HTMLSpanElement>>;
+declare const formatNumber: (value: number, options?: Partial<Omit<NumberFormatterProps, "className" | "style" | "id">>) => string;
+declare const formatCurrency: (value: number, currency?: string, locale?: string) => string;
+declare const formatPercent: (value: number, decimalPlaces?: number, locale?: string) => string;
+declare const formatCompact: (value: number, locale?: string) => string;
+
+interface SortableItem {
+    id: string | number;
+    [key: string]: unknown;
+}
+interface SortableProps<T extends SortableItem> extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Items to sort */
+    items: T[];
+    /** On items reorder */
+    onReorder: (items: T[]) => void;
+    /** Render item function */
+    renderItem: (item: T, index: number, isDragging: boolean, dragHandleProps: DragHandleProps) => ReactNode;
+    /** Direction of the list */
+    direction?: 'vertical' | 'horizontal';
+    /** Gap between items */
+    gap?: number;
+    /** Handle selector (if not provided, entire item is draggable) */
+    handleSelector?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Lock axis during drag */
+    lockAxis?: 'x' | 'y' | null;
+    /** Placeholder style */
+    placeholderStyle?: CSSProperties;
+}
+interface DragHandleProps {
+    draggable: boolean;
+    onDragStart: (e: React.DragEvent) => void;
+    onDragEnd: (e: React.DragEvent) => void;
+    'data-drag-handle': boolean;
+    style: CSSProperties;
+}
+declare const Sortable: <T extends SortableItem>(props: SortableProps<T> & {
+    ref?: React.ForwardedRef<HTMLDivElement>;
+}) => JSX.Element;
+interface SortableHandleProps extends HTMLAttributes<HTMLDivElement> {
+    /** Drag handle props from parent */
+    dragHandleProps?: DragHandleProps;
+}
+declare const SortableHandle: react.ForwardRefExoticComponent<SortableHandleProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ErrorBoundaryProps {
+    /** Children to render */
+    children: ReactNode;
+    /** Fallback UI when error occurs */
+    fallback?: ReactNode | ((error: Error, resetError: () => void) => ReactNode);
+    /** Error callback */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /** Reset callback */
+    onReset?: () => void;
+    /** Reset keys - when these change, the error boundary resets */
+    resetKeys?: unknown[];
+    /** Class name */
+    className?: string;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    static displayName: string;
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
+    resetError: () => void;
+    render(): ReactNode;
+}
+interface UseErrorBoundaryReturn {
+    showBoundary: (error: Error) => void;
+}
+interface ErrorBoundaryWrapperProps extends Omit<ErrorBoundaryProps, 'fallback'> {
+    /** Fallback component */
+    FallbackComponent?: React.ComponentType<{
+        error: Error;
+        resetError: () => void;
+    }>;
+}
+declare const withErrorBoundary: <P extends object>(WrappedComponent: React.ComponentType<P>, errorBoundaryProps?: Omit<ErrorBoundaryProps, "children">) => React.FC<P>;
+interface ErrorFallbackProps {
+    error: Error;
+    resetError: () => void;
+    title?: string;
+    message?: string;
+    showStack?: boolean;
+    className?: string;
+}
+declare const ErrorFallback: React.FC<ErrorFallbackProps>;
+
+interface RichTextEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Editor value (HTML string) */
+    value?: string;
+    /** Default value */
+    defaultValue?: string;
+    /** On change callback */
+    onChange?: (value: string) => void;
+    /** On blur callback */
+    onBlur?: () => void;
+    /** On focus callback */
+    onFocus?: () => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Read-only state */
+    readOnly?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Min height */
+    minHeight?: number | string;
+    /** Max height */
+    maxHeight?: number | string;
+    /** Toolbar options */
+    toolbar?: ToolbarOption[];
+    /** Hide toolbar */
+    hideToolbar?: boolean;
+    /** Sticky toolbar */
+    stickyToolbar?: boolean;
+    /** Auto focus */
+    autoFocus?: boolean;
+}
+type ToolbarOption = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'heading1' | 'heading2' | 'heading3' | 'bulletList' | 'orderedList' | 'blockquote' | 'code' | 'link' | 'image' | 'alignLeft' | 'alignCenter' | 'alignRight' | 'undo' | 'redo' | 'clear';
+declare const RichTextEditor: react.ForwardRefExoticComponent<RichTextEditorProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SparklineProps extends Omit<SVGAttributes<SVGSVGElement>, 'children'> {
+    /** Data points */
+    data: number[];
+    /** Chart type */
+    type?: 'line' | 'bar' | 'area';
+    /** Width */
+    width?: number;
+    /** Height */
+    height?: number;
+    /** Stroke color */
+    stroke?: string;
+    /** Fill color (for area/bar) */
+    fill?: string;
+    /** Stroke width */
+    strokeWidth?: number;
+    /** Show dots on data points */
+    showDots?: boolean;
+    /** Dot radius */
+    dotRadius?: number;
+    /** Curved line */
+    curved?: boolean;
+    /** Highlight min/max */
+    highlightMinMax?: boolean;
+    /** Min color */
+    minColor?: string;
+    /** Max color */
+    maxColor?: string;
+    /** Bar gap ratio (0-1) */
+    barGap?: number;
+    /** Animation duration */
+    animationDuration?: number;
+    /** Reference line value */
+    referenceLine?: number;
+    /** Reference line color */
+    referenceLineColor?: string;
+    /** Tooltip formatter */
+    tooltipFormatter?: (value: number, index: number) => string;
+}
+declare const Sparkline: react.ForwardRefExoticComponent<SparklineProps & react.RefAttributes<SVGSVGElement>>;
+
+interface GaugeProps extends Omit<SVGAttributes<SVGSVGElement>, 'children'> {
+    /** Current value */
+    value: number;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Size of the gauge */
+    size?: number;
+    /** Thickness of the arc */
+    thickness?: number;
+    /** Start angle in degrees (0 is top) */
+    startAngle?: number;
+    /** End angle in degrees */
+    endAngle?: number;
+    /** Color of the filled arc */
+    color?: string;
+    /** Background color of the arc */
+    trackColor?: string;
+    /** Show value label */
+    showValue?: boolean;
+    /** Value formatter */
+    valueFormatter?: (value: number) => string;
+    /** Value label */
+    label?: ReactNode;
+    /** Sub label */
+    subLabel?: ReactNode;
+    /** Gradient colors */
+    gradient?: {
+        offset: number;
+        color: string;
+    }[];
+    /** Color segments */
+    segments?: {
+        start: number;
+        end: number;
+        color: string;
+    }[];
+    /** Show ticks */
+    showTicks?: boolean;
+    /** Number of ticks */
+    tickCount?: number;
+    /** Animated */
+    animated?: boolean;
+    /** Animation duration */
+    animationDuration?: number;
+    /** Needle style */
+    needle?: boolean;
+    /** Needle color */
+    needleColor?: string;
+}
+declare const Gauge: react.ForwardRefExoticComponent<GaugeProps & react.RefAttributes<SVGSVGElement>>;
+
+interface LazyLoadProps extends HTMLAttributes<HTMLDivElement> {
+    /** Children to lazy load */
+    children: ReactNode;
+    /** Placeholder content while loading */
+    placeholder?: ReactNode;
+    /** Height of the placeholder */
+    height?: number | string;
+    /** Width of the placeholder */
+    width?: number | string;
+    /** Offset from viewport to trigger load */
+    offset?: number | string;
+    /** Root margin for intersection observer */
+    rootMargin?: string;
+    /** Threshold for intersection observer */
+    threshold?: number | number[];
+    /** Once loaded, keep rendered */
+    once?: boolean;
+    /** Callback when element becomes visible */
+    onVisible?: () => void;
+    /** Callback when element is hidden */
+    onHidden?: () => void;
+    /** Animation when appearing */
+    animation?: 'fade' | 'slide' | 'zoom' | 'none';
+    /** Animation duration */
+    animationDuration?: number;
+    /** Disabled lazy loading */
+    disabled?: boolean;
+    /** Use skeleton placeholder */
+    skeleton?: boolean;
+    /** Skeleton animation */
+    skeletonAnimation?: 'pulse' | 'wave' | 'none';
+}
+declare const LazyLoad: react.ForwardRefExoticComponent<LazyLoadProps & react.RefAttributes<HTMLDivElement>>;
+interface LazyImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'onLoad' | 'onError'> {
+    /** Placeholder image src */
+    placeholderSrc?: string;
+    /** Blur placeholder data URL */
+    blurDataURL?: string;
+    /** On load callback */
+    onLoad?: () => void;
+    /** On error callback */
+    onError?: () => void;
+    /** Offset from viewport */
+    offset?: number | string;
+    /** Animation style */
+    animation?: 'fade' | 'blur' | 'none';
+    /** Animation duration */
+    animationDuration?: number;
+}
+declare const LazyImage: react.ForwardRefExoticComponent<LazyImageProps & react.RefAttributes<HTMLImageElement>>;
+
+type GroupGap = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 0;
+type GroupJustify = 'left' | 'center' | 'right' | 'apart' | 'around' | 'evenly';
+type GroupAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+interface GroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Gap between items */
+    gap?: GroupGap;
+    /** Horizontal alignment */
+    justify?: GroupJustify;
+    /** Vertical alignment */
+    align?: GroupAlign;
+    /** Prevent items from wrapping */
+    nowrap?: boolean;
+    /** Allow items to grow to fill space */
+    grow?: boolean;
+    /** Prevent items from growing */
+    preventGrow?: boolean;
+}
+declare const Group: react.ForwardRefExoticComponent<GroupProps & react.RefAttributes<HTMLDivElement>>;
+
+type FloatPlacement = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'left-center' | 'right-center' | 'center';
+type FloatOffset = 1 | 2 | 3 | 4;
+interface FloatProps extends HTMLAttributes<HTMLDivElement> {
+    /** Position of the floating element */
+    placement?: FloatPlacement;
+    /** Offset from the edge */
+    offset?: FloatOffset;
+    /** Place element outside the container */
+    outside?: boolean;
+}
+declare const Float: react.ForwardRefExoticComponent<FloatProps & react.RefAttributes<HTMLDivElement>>;
+
+type OverlayOpacity = 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90;
+type OverlayBlur = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type OverlayRadius = 'sm' | 'md' | 'lg';
+interface OverlayProps extends HTMLAttributes<HTMLDivElement> {
+    /** Background opacity (10-90) */
+    opacity?: OverlayOpacity;
+    /** Backdrop blur level */
+    blur?: OverlayBlur;
+    /** Use fixed positioning instead of absolute */
+    fixed?: boolean;
+    /** Center content within overlay */
+    center?: boolean;
+    /** Use white background instead of black */
+    white?: boolean;
+    /** Use gradient background */
+    gradient?: boolean;
+    /** Border radius */
+    radius?: OverlayRadius;
+    /** Custom z-index */
+    zIndex?: number;
+}
+declare const Overlay: react.ForwardRefExoticComponent<OverlayProps & react.RefAttributes<HTMLDivElement>>;
+
+type ActionIconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type ActionIconVariant = 'default' | 'filled' | 'light' | 'outline' | 'subtle' | 'transparent';
+type ActionIconColor = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+interface ActionIconProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Icon size */
+    size?: ActionIconSize;
+    /** Visual variant */
+    variant?: ActionIconVariant;
+    /** Color theme */
+    color?: ActionIconColor;
+    /** Loading state */
+    loading?: boolean;
+    /** Custom loader element */
+    loader?: ReactNode;
+}
+declare const ActionIcon: react.ForwardRefExoticComponent<ActionIconProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface UnstyledButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Make button full width */
+    block?: boolean;
+}
+declare const UnstyledButton: react.ForwardRefExoticComponent<UnstyledButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface FileButtonProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'children' | 'onChange'> {
+    /** Render function for the button */
+    children: (props: {
+        onClick: () => void;
+    }) => ReactNode;
+    /** Callback when files are selected */
+    onChange?: (files: File | File[] | null) => void;
+    /** Allow multiple file selection */
+    multiple?: boolean;
+    /** Reset input value after each selection */
+    resetRef?: React.RefObject<() => void>;
+}
+interface FileButtonRef {
+    reset: () => void;
+}
+declare const FileButton: react.ForwardRefExoticComponent<FileButtonProps & react.RefAttributes<FileButtonRef>>;
+
+type FloatingIndicatorVariant = 'default' | 'filled' | 'light' | 'outline';
+interface FloatingIndicatorProps extends HTMLAttributes<HTMLDivElement> {
+    /** Visual variant */
+    variant?: FloatingIndicatorVariant;
+    /** Disable transition animation */
+    noTransition?: boolean;
+    /** Hide the indicator */
+    hidden?: boolean;
+    /** Target element dimensions and position */
+    target?: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    };
+}
+declare const FloatingIndicator: react.ForwardRefExoticComponent<FloatingIndicatorProps & react.RefAttributes<HTMLDivElement>>;
+
+type PillSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type PillVariant = 'default' | 'filled' | 'outline';
+interface PillProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Size variant */
+    size?: PillSize;
+    /** Visual variant */
+    variant?: PillVariant;
+    /** Show remove button */
+    withRemoveButton?: boolean;
+    /** Callback when remove button clicked */
+    onRemove?: () => void;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Icon displayed before label */
+    leftSection?: ReactNode;
+}
+declare const Pill: react.ForwardRefExoticComponent<PillProps & react.RefAttributes<HTMLSpanElement>>;
+
+type MarkColor = 'yellow' | 'blue' | 'cyan' | 'green' | 'lime' | 'orange' | 'pink' | 'red' | 'grape' | 'violet' | 'indigo' | 'teal' | 'dark' | 'light';
+interface MarkProps extends HTMLAttributes<HTMLElement> {
+    /** Highlight color */
+    color?: MarkColor;
+}
+declare const Mark: react.ForwardRefExoticComponent<MarkProps & react.RefAttributes<HTMLElement>>;
+
+type UserSize = 'xs' | 'sm' | 'md' | 'lg';
+interface UserProps extends HTMLAttributes<HTMLDivElement> {
+    /** User's display name */
+    name: string;
+    /** Description or subtitle */
+    description?: string;
+    /** Avatar element */
+    avatar?: ReactNode;
+    /** Size variant */
+    size?: UserSize;
+    /** Show border around avatar */
+    bordered?: boolean;
+    /** Make user card interactive/clickable */
+    interactive?: boolean;
+    /** Use squared avatar instead of circular */
+    squared?: boolean;
+    /** Vertical layout */
+    vertical?: boolean;
+}
+declare const User: react.ForwardRefExoticComponent<UserProps & react.RefAttributes<HTMLDivElement>>;
+
+type DataListSize = 'sm' | 'md' | 'lg';
+type DataListOrientation = 'vertical' | 'horizontal';
+interface DataListItemProps {
+    /** Label for the data item */
+    label: string;
+    /** Value to display */
+    value: ReactNode;
+}
+interface DataListProps extends HTMLAttributes<HTMLDListElement> {
+    /** Data items to display */
+    items: DataListItemProps[];
+    /** Size variant */
+    size?: DataListSize;
+    /** Layout orientation */
+    orientation?: DataListOrientation;
+    /** Display items inline (label and value on same line) */
+    inline?: boolean;
+    /** Add dividers between items */
+    divided?: boolean;
+    /** Striped background */
+    striped?: boolean;
+}
+declare const DataList: react.ForwardRefExoticComponent<DataListProps & react.RefAttributes<HTMLDListElement>>;
+
+type BackgroundImageRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type BackgroundImageRatio = '16-9' | '4-3' | '1-1' | '21-9';
+type BackgroundImageOverlay = 'dark' | 'light' | 'gradient';
+interface BackgroundImageProps extends HTMLAttributes<HTMLDivElement> {
+    /** Image source URL */
+    src: string;
+    /** Border radius */
+    radius?: BackgroundImageRadius;
+    /** Aspect ratio */
+    ratio?: BackgroundImageRatio;
+    /** Fill container (width and height 100%) */
+    fill?: boolean;
+    /** Fixed background attachment (parallax effect) */
+    fixed?: boolean;
+    /** Overlay type */
+    overlay?: BackgroundImageOverlay;
+    /** Content to render on top of the image */
+    children?: ReactNode;
+}
+declare const BackgroundImage: react.ForwardRefExoticComponent<BackgroundImageProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SkipNavLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Target content ID (without #) */
+    contentId?: string;
+    /** Position in center of screen instead of top-left */
+    center?: boolean;
+}
+declare const SkipNavLink: react.ForwardRefExoticComponent<SkipNavLinkProps & react.RefAttributes<HTMLAnchorElement>>;
+interface SkipNavContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Content ID (must match SkipNavLink's contentId) */
+    id?: string;
+}
+declare const SkipNavContent: react.ForwardRefExoticComponent<SkipNavContentProps & react.RefAttributes<HTMLDivElement>>;
+
+type AbsoluteCenterAxis = 'both' | 'horizontal' | 'vertical';
+interface AbsoluteCenterProps extends HTMLAttributes<HTMLDivElement> {
+    /** Axis to center on */
+    axis?: AbsoluteCenterAxis;
+}
+declare const AbsoluteCenter: react.ForwardRefExoticComponent<AbsoluteCenterProps & react.RefAttributes<HTMLDivElement>>;
+
+type PillsInputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type PillsInputVariant = 'default' | 'filled' | 'unstyled';
+interface PillsInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** Pills to display */
+    children?: ReactNode;
+    /** Size variant */
+    size?: PillsInputSize;
+    /** Visual variant */
+    variant?: PillsInputVariant;
+    /** Error state */
+    error?: boolean;
+    /** Callback when wrapper is clicked */
+    onWrapperClick?: () => void;
+}
+interface PillsInputFieldProps extends InputHTMLAttributes<HTMLInputElement> {
+    /** Callback when Enter is pressed */
+    onEnter?: (value: string) => void;
+}
+declare const PillsInput: react.ForwardRefExoticComponent<PillsInputProps & react.RefAttributes<HTMLDivElement>>;
+declare const PillsInputField: react.ForwardRefExoticComponent<PillsInputFieldProps & react.RefAttributes<HTMLInputElement>>;
+
+type BurgerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface BurgerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Whether the burger is in opened state */
+    opened: boolean;
+    /** Size variant */
+    size?: BurgerSize;
+    /** Accessible label */
+    'aria-label'?: string;
+}
+declare const Burger: react.ForwardRefExoticComponent<BurgerProps & react.RefAttributes<HTMLButtonElement>>;
+
+type ListboxSize = 'sm' | 'md' | 'lg';
+interface ListboxProps extends HTMLAttributes<HTMLDivElement> {
+    /** Size variant */
+    size?: ListboxSize;
+    /** Allow multiple selection */
+    multiple?: boolean;
+}
+interface ListboxButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Placeholder text when no selection */
+    placeholder?: string;
+    /** Icon to show */
+    icon?: ReactNode;
+}
+interface ListboxOptionsProps extends HTMLAttributes<HTMLUListElement> {
+}
+interface ListboxOptionProps extends HTMLAttributes<HTMLLIElement> {
+    /** Option value */
+    value: string;
+    /** Whether option is selected */
+    selected?: boolean;
+    /** Whether option is disabled */
+    disabled?: boolean;
+    /** Whether option is currently active/focused */
+    active?: boolean;
+    /** Icon to display */
+    icon?: ReactNode;
+    /** Description text */
+    description?: string;
+}
+interface ListboxGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Group label */
+    label: string;
+}
+declare const Listbox: react.ForwardRefExoticComponent<ListboxProps & react.RefAttributes<HTMLDivElement>>;
+declare const ListboxButton: react.ForwardRefExoticComponent<ListboxButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare const ListboxOptions: react.ForwardRefExoticComponent<ListboxOptionsProps & react.RefAttributes<HTMLUListElement>>;
+declare const ListboxOption: react.ForwardRefExoticComponent<ListboxOptionProps & react.RefAttributes<HTMLLIElement>>;
+declare const ListboxGroup: react.ForwardRefExoticComponent<ListboxGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const ListboxDivider: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const ListboxEmpty: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+interface LinkBoxProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface LinkOverlayProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Remove default link styling */
+    unstyled?: boolean;
+}
+/**
+ * LinkBox - Container that makes its child LinkOverlay cover the entire box.
+ * Use this to make entire cards or sections clickable while keeping other
+ * interactive elements accessible.
+ */
+declare const LinkBox: react.ForwardRefExoticComponent<LinkBoxProps & react.RefAttributes<HTMLDivElement>>;
+/**
+ * LinkOverlay - A link that stretches to cover its nearest LinkBox parent.
+ * Place this inside a LinkBox to make the entire box clickable.
+ */
+declare const LinkOverlay: react.ForwardRefExoticComponent<LinkOverlayProps & react.RefAttributes<HTMLAnchorElement>>;
+
+type ToggletipPlacement = 'top' | 'bottom' | 'left' | 'right';
+interface ToggletipProps extends HTMLAttributes<HTMLDivElement> {
+    /** Controlled open state */
+    open?: boolean;
+    /** Default open state (uncontrolled) */
+    defaultOpen?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Placement of the content */
+    placement?: ToggletipPlacement;
+    /** Show close button in content */
+    withCloseButton?: boolean;
+}
+interface ToggletipTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Icon to display */
+    icon?: ReactNode;
+}
+interface ToggletipContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const Toggletip: react.ForwardRefExoticComponent<ToggletipProps & react.RefAttributes<HTMLDivElement>>;
+declare const ToggletipTrigger: react.ForwardRefExoticComponent<ToggletipTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const ToggletipContent: react.ForwardRefExoticComponent<ToggletipContentProps & react.RefAttributes<HTMLDivElement>>;
+interface ToggletipCloseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const ToggletipClose: react.ForwardRefExoticComponent<ToggletipCloseProps & react.RefAttributes<HTMLButtonElement>>;
+
+type DisclosureSize = 'sm' | 'md' | 'lg';
+type DisclosureVariant = 'default' | 'flush' | 'card';
+interface DisclosureProps extends HTMLAttributes<HTMLDivElement> {
+    /** Controlled open state */
+    open?: boolean;
+    /** Default open state (uncontrolled) */
+    defaultOpen?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Size variant */
+    size?: DisclosureSize;
+    /** Visual variant */
+    variant?: DisclosureVariant;
+    /** Disabled state */
+    disabled?: boolean;
+}
+interface DisclosureButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Icon to display */
+    icon?: ReactNode;
+}
+interface DisclosurePanelProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface DisclosureGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Whether only one item can be open at a time */
+    accordion?: boolean;
+    /** Separated items (with gap) */
+    separated?: boolean;
+}
+declare const Disclosure: react.ForwardRefExoticComponent<DisclosureProps & react.RefAttributes<HTMLDivElement>>;
+declare const DisclosureButton: react.ForwardRefExoticComponent<DisclosureButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DisclosurePanel: react.ForwardRefExoticComponent<DisclosurePanelProps & react.RefAttributes<HTMLDivElement>>;
+declare const DisclosureGroup: react.ForwardRefExoticComponent<DisclosureGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+type RangeCalendarSize = 'sm' | 'md' | 'lg';
+interface CalendarDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface RangeCalendarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** Selected date range */
+    value?: CalendarDateRange;
+    /** Default date range (uncontrolled) */
+    defaultValue?: CalendarDateRange;
+    /** Callback when range changes */
+    onChange?: (range: CalendarDateRange) => void;
+    /** Minimum selectable date */
+    minDate?: Date;
+    /** Maximum selectable date */
+    maxDate?: Date;
+    /** Size variant */
+    size?: RangeCalendarSize;
+    /** Show two months side by side */
+    dual?: boolean;
+    /** Locale for formatting */
+    locale?: string;
+    /** Week starts on (0 = Sunday, 1 = Monday) */
+    weekStartsOn?: 0 | 1;
+    /** Preset ranges */
+    presets?: Array<{
+        label: string;
+        value: CalendarDateRange;
+    }>;
+}
+declare const RangeCalendar: react.ForwardRefExoticComponent<RangeCalendarProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ClientOnlyProps {
+    /** Content to render only on client */
+    children: ReactNode;
+    /** Fallback to show during SSR */
+    fallback?: ReactNode;
+}
+/**
+ * ClientOnly - Renders children only on the client side.
+ * Useful for components that depend on browser APIs or need to avoid hydration mismatches.
+ */
+declare function ClientOnly({ children, fallback }: ClientOnlyProps): react_jsx_runtime.JSX.Element;
+declare namespace ClientOnly {
+    var displayName: string;
+}
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { AbsoluteCenter, type AbsoluteCenterAxis, type AbsoluteCenterProps, ActionIcon, type ActionIconColor, type ActionIconProps, type ActionIconSize, type ActionIconVariant, Affix, type AffixProps, Alert, AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, type AlertDialogDescriptionProps, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, type AlertDialogProps, AlertDialogTitle, type AlertDialogTitleProps, type AlertProps, Anchor, type AnchorItem, type AnchorProps, AngleSlider, type AngleSliderProps, AppBar, type AppBarProps, AppBarToolbar, type AppBarToolbarProps, AppShell, AppShellAside, type AppShellAsideProps, type AppShellContextValue, AppShellFooter, type AppShellFooterProps, AppShellHeader, type AppShellHeaderProps, AppShellMain, type AppShellMainProps, AppShellNavbar, type AppShellNavbarProps, type AppShellProps, AspectRatio, type AspectRatioProps, Autocomplete, type AutocompleteOption, type AutocompleteProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, BackTop, type BackTopProps, Backdrop, type BackdropProps, BackgroundImage, type BackgroundImageOverlay, type BackgroundImageProps, type BackgroundImageRadius, type BackgroundImageRatio, Badge, type BadgeProps, type BaseProps, Blockquote, type BlockquoteProps, BottomNavigation, BottomNavigationItem, type BottomNavigationItemProps, type BottomNavigationProps, Box, type BoxProps, Breadcrumb, BreadcrumbItem, type BreadcrumbItemProps, type BreadcrumbProps, Burger, type BurgerProps, type BurgerSize, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, type ButtonVariant, Calendar, type CalendarDateRange, type CalendarProps, Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, Carousel, CarouselItem, type CarouselItemProps, type CarouselProps, Cascader, type CascaderOption, type CascaderProps, Center, type CenterProps, Chart, type ChartDataPoint, type ChartProps, Checkbox, CheckboxCard, type CheckboxCardProps, CheckboxGroup, type CheckboxGroupContextValue, CheckboxGroupItem, type CheckboxGroupItemProps, type CheckboxGroupOption, type CheckboxGroupProps, type CheckboxProps, Chip, ChipGroup, type ChipGroupProps, type ChipProps, CircularProgress, type CircularProgressProps, ClientOnly, type ClientOnlyProps, CloseButton, type CloseButtonProps, Code, CodeBlock, type CodeBlockProps, type CodeProps, Col, type ColProps, Collapse, CollapsePanel, type CollapsePanelProps, type CollapseProps, ColorInput, type ColorInputProps, ColorPicker, type ColorPickerProps, type ColorScheme$1 as ColorScheme, ColorSwatch, type ColorSwatchProps, Combobox, type ComboboxOption, type ComboboxProps, type CommandItem, CommandPalette, type CommandPaletteProps, type ConfigContextValue, ConfigProvider, type ConfigProviderProps, Container, type ContainerProps, ContextMenu, type ContextMenuItem, type ContextMenuProps, ContextMenuSeparator, CopyButton, type CopyButtonProps, DataGrid, type DataGridColumn, type DataGridProps, DataList, type DataListItemProps, type DataListOrientation, type DataListProps, type DataListSize, DatePicker, type DatePickerProps, type DateRange, DateRangePicker, type DateRangePickerProps, DateTimePicker, type DateTimePickerProps, Descriptions, DescriptionsItem, type DescriptionsItemProps, type DescriptionsProps, Dialog, DialogBody, type DialogBodyProps, DialogClose, type DialogCloseProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, type DialogProps, Disclosure, DisclosureButton, type DisclosureButtonProps, DisclosureGroup, type DisclosureGroupProps, DisclosurePanel, type DisclosurePanelProps, type DisclosureProps, type DisclosureSize, type DisclosureVariant, Divider, type DividerProps, type DragHandleProps, Drawer, type DrawerProps, Dropdown, DropdownDivider, type DropdownDividerProps, DropdownHeader, type DropdownHeaderProps, DropdownItem, type DropdownItemProps, DropdownMenu, type DropdownMenuProps, type DropdownProps, DropdownTrigger, type DropdownTriggerProps, Dropzone, type DropzoneProps, Editable, type EditableProps, Empty, type EmptyProps, ErrorBoundary, type ErrorBoundaryProps, type ErrorBoundaryWrapperProps, ErrorFallback, type ErrorFallbackProps, Field, type FieldProps, Fieldset, type FieldsetProps, FileButton, type FileButtonProps, type FileButtonRef, FileInput, type FileInputProps, Flex, type FlexProps, Float, FloatBackTop, type FloatBackTopProps, FloatButton, FloatButtonGroup, type FloatButtonGroupProps, type FloatButtonProps, type FloatOffset, type FloatPlacement, type FloatProps, FloatingIndicator, type FloatingIndicatorProps, type FloatingIndicatorVariant, FocusTrap, type FocusTrapProps, Form, FormItem, type FormItemProps, type FormProps, Gauge, type GaugeProps, Grid, type GridProps, Group, type GroupAlign, type GroupGap, type GroupJustify, type GroupProps, HStack, type HStackProps, Heading, type HeadingProps, HeadingText, Highlight, type HighlightProps, HoverCard, HoverCardBody, type HoverCardBodyProps, HoverCardFooter, type HoverCardFooterProps, HoverCardHeader, type HoverCardHeaderProps, type HoverCardProps, Icon, IconButton, type IconButtonProps, type IconProps, Icons, Image, ImageList, ImageListItem, ImageListItemBar, type ImageListItemBarProps, type ImageListItemProps, ImageListItem as ImageListItemType, type ImageListProps, type ImageProps, Indicator, type IndicatorProps, InfiniteScroll, type InfiniteScrollProps, Input, InputOTP, type InputOTPProps, type InputProps, JsonInput, type JsonInputProps, Kbd, type KbdProps, Label, type LabelProps, LazyImage, type LazyImageProps, LazyLoad, type LazyLoadProps, Link, LinkBox, type LinkBoxProps, LinkOverlay, type LinkOverlayProps, type LinkProps, List, ListItem, ListItemMeta, type ListItemMetaProps, type ListItemProps, type ListProps, Listbox, ListboxButton, type ListboxButtonProps, ListboxDivider, ListboxEmpty, ListboxGroup, type ListboxGroupProps, ListboxOption, type ListboxOptionProps, ListboxOptions, type ListboxOptionsProps, type ListboxProps, type ListboxSize, LoadingOverlay, type LoadingOverlayProps, Mark, type MarkColor, type MarkProps, Masonry, MasonryItem, type MasonryItemProps, type MasonryProps, type MentionOption, Mentions, type MentionsProps, Menu, MenuDivider, type MenuDividerProps, MenuGroup, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuProps, Menubar, type MenubarItem, MenubarMenu, type MenubarMenuProps, type MenubarProps, Message, MessageContainer, type MessageContainerProps, type MessageProps, type MessageType, Modal, ModalBody, ModalFooter, ModalHeader, type ModalHeaderProps, type ModalProps, MonthPicker, type MonthPickerProps, MultiSelect, type MultiSelectOption, type MultiSelectProps, NavLink, type NavLinkProps, Navbar, NavbarBrand, type NavbarBrandProps, NavbarContent, type NavbarContentProps, NavbarItem, type NavbarItemProps, NavbarMenu, NavbarMenuItem, type NavbarMenuItemProps, type NavbarMenuProps, NavbarMenuToggle, type NavbarMenuToggleProps, type NavbarProps, NavigationMenu, NavigationMenuContent, type NavigationMenuContentProps, NavigationMenuIndicator, type NavigationMenuIndicatorProps, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, type NavigationMenuLinkProps, type NavigationMenuProps, NavigationMenuTrigger, type NavigationMenuTriggerProps, NavigationMenuViewport, type NavigationMenuViewportProps, Notification, NotificationContainer, type NotificationProps, NumberFormatter, type NumberFormatterProps, NumberInput, type NumberInputProps, Overlay, type OverlayBlur, type OverlayOpacity, type OverlayProps, type OverlayRadius, Pagination, type PaginationProps, Paper, type PaperProps, PasswordInput, type PasswordInputProps, Pill, type PillProps, type PillSize, type PillVariant, PillsInput, PillsInputField, type PillsInputFieldProps, type PillsInputProps, type PillsInputSize, type PillsInputVariant, PinInput, type PinInputProps, type PolymorphicComponentProps, type PolymorphicComponentPropsWithRef, type PolymorphicRef, Popconfirm, type PopconfirmProps, Popover, type PopoverProps, Portal, type PortalProps, Progress, type ProgressProps, QRCode, type QRCodeProps, Radio, RadioCard, RadioCardGroup, type RadioCardGroupProps, type RadioCardProps, RadioGroup, type RadioGroupProps, type RadioProps, RangeCalendar, type RangeCalendarProps, type RangeCalendarSize, RangeSlider, type RangeSliderProps, Rate, type RateProps, Resizable, type ResizableProps, type ResizeDirection, Result, type ResultProps, RichTextEditor, type RichTextEditorProps, RingProgress, type RingProgressProps, type RingProgressSection, ScrollArea, type ScrollAreaProps, ScrollShadow, type ScrollShadowProps, Segmented, type SegmentedOption, type SegmentedProps, Select, type SelectOption, type SelectOptionGroup, type SelectProps, SemiCircleProgress, type SemiCircleProgressProps, Separator, type SeparatorProps, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, SheetDescription, type SheetDescriptionProps, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, type SheetProps, SheetTitle, type SheetTitleProps, Sidebar, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarToggle, type SidebarToggleProps, SimpleGrid, type SimpleGridProps, type Size, Skeleton, SkeletonAvatar, type SkeletonAvatarProps, SkeletonCard, type SkeletonCardProps, type SkeletonProps, SkipNavContent, type SkipNavContentProps, SkipNavLink, type SkipNavLinkProps, Slider, type SliderProps, Snippet, type SnippetProps, Sortable, SortableHandle, type SortableHandleProps, type SortableItem, type SortableProps, Space, type SpaceProps, Sparkline, type SparklineProps, SpeedDial, type SpeedDialAction, type SpeedDialProps, Spinner, type SpinnerProps, SplitButton, type SplitButtonOption, type SplitButtonProps, Splitter, SplitterPanel, type SplitterPanelProps, type SplitterProps, Spoiler, type SpoilerProps, Stack, type StackProps, Statistic, StatisticGroup, type StatisticGroupProps, type StatisticProps, Step, type StepProps, Stepper, type StepperContextValue, type StepperProps, StepperStep, type StepperStepProps, Steps, type StepsProps, SubMenu, type SubMenuProps, Switch, type SwitchProps, Tab, TabList, type TabListProps, TabPanel, type TabPanelProps, type TabProps, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableFoot, type TableFootProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, TableOfContents, type TableOfContentsItem, type TableOfContentsProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsProps, Tag, type TagProps, TagsInput, type TagsInputProps, Text, TextBlock, type TextProps, Textarea, type TextareaProps, ThemeIcon, type ThemeIconProps, TimePicker, type TimePickerProps, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, Toast, ToastContainer, type ToastContainerProps, type ToastProps, Toggle, ToggleGroup, ToggleGroupItem, type ToggleGroupItemProps, type ToggleGroupProps, type ToggleProps, Toggletip, ToggletipClose, type ToggletipCloseProps, ToggletipContent, type ToggletipContentProps, type ToggletipPlacement, type ToggletipProps, ToggletipTrigger, type ToggletipTriggerProps, Toolbar, ToolbarButton, type ToolbarButtonProps, ToolbarGroup, type ToolbarGroupProps, ToolbarLink, type ToolbarLinkProps, type ToolbarProps, ToolbarSeparator, type ToolbarSeparatorProps, ToolbarToggleGroup, type ToolbarToggleGroupProps, Tooltip, type TooltipProps, Tour, type TourProps, type TourStep, Transfer, type TransferItem, type TransferProps, Transition, type TransitionProps, type TransitionType, Tree, type TreeNode, type TreeProps, TreeSelect, type TreeSelectNode, type TreeSelectProps, Typography, type TypographyProps, UnstyledButton, type UnstyledButtonProps, Upload, type UploadFile, type UploadProps, type UseErrorBoundaryReturn, User, type UserProps, type UserSize, VStack, type VStackProps, type Variant, VirtualList, type VirtualListProps, VisuallyHidden, type VisuallyHiddenProps, Watermark, type WatermarkProps, YearPicker, type YearPickerProps, ZenKitProvider, type ZenKitProviderProps, cn, formatCompact, formatCurrency, formatNumber, formatPercent, useAppShell, useCheckboxGroup, useConfig, useFormContext, useRadioCardGroup, useSidebar, useStepper, useTheme, useThemeOptional, useToolbar, visuallyHiddenStyles, withErrorBoundary };