@reeverdev/ui 0.2.98 → 0.2.99

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import * as React$1 from 'react';
+import { RefObject } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Toaster as Toaster$1 } from 'sonner';
@@ -77,6 +78,8 @@ interface CardProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps
 }
 declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;
 declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
 declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
 declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
 
@@ -308,10 +311,9 @@ interface DropdownProps {
     onOpenChange?: (open: boolean) => void;
 }
 declare const Dropdown: React$1.FC<DropdownProps>;
-interface DropdownTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
-    asChild?: boolean;
+interface DropdownTriggerProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const DropdownTrigger: React$1.ForwardRefExoticComponent<DropdownTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownTrigger: React$1.ForwardRefExoticComponent<DropdownTriggerProps & React$1.RefAttributes<HTMLDivElement>>;
 interface DropdownContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
     side?: Side$2;
     sideOffset?: number;
@@ -327,28 +329,16 @@ interface DropdownItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
     inset?: boolean;
     disabled?: boolean;
     onSelect?: () => void;
+    /** Icon or element to show before the content */
+    startContent?: React$1.ReactNode;
+    /** Icon or element to show after the content */
+    endContent?: React$1.ReactNode;
 }
 declare const DropdownItem: React$1.ForwardRefExoticComponent<DropdownItemProps & React$1.RefAttributes<HTMLDivElement>>;
-interface DropdownCheckboxItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    checked?: boolean;
-    onCheckedChange?: (checked: boolean) => void;
-    disabled?: boolean;
-}
-declare const DropdownCheckboxItem: React$1.ForwardRefExoticComponent<DropdownCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>>;
-interface DropdownRadioGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    value?: string;
-    onValueChange?: (value: string) => void;
-}
-declare const DropdownRadioGroup: React$1.ForwardRefExoticComponent<DropdownRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
-interface DropdownRadioItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    value: string;
-    disabled?: boolean;
-}
-declare const DropdownRadioItem: React$1.ForwardRefExoticComponent<DropdownRadioItemProps & React$1.RefAttributes<HTMLDivElement>>;
-interface DropdownLabelProps extends React$1.HTMLAttributes<HTMLDivElement> {
+interface DropdownSectionProps extends React$1.HTMLAttributes<HTMLDivElement> {
     inset?: boolean;
 }
-declare const DropdownLabel: React$1.ForwardRefExoticComponent<DropdownLabelProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownSection: React$1.ForwardRefExoticComponent<DropdownSectionProps & React$1.RefAttributes<HTMLDivElement>>;
 interface DropdownSeparatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
 declare const DropdownSeparator: React$1.ForwardRefExoticComponent<DropdownSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
@@ -377,6 +367,7 @@ interface DropdownSubContentProps extends React$1.HTMLAttributes<HTMLDivElement>
     collisionPadding?: number;
 }
 declare const DropdownSubContent: React$1.ForwardRefExoticComponent<DropdownSubContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownLabel: React$1.ForwardRefExoticComponent<DropdownSectionProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface PopoverProps {
     children: React$1.ReactNode;
@@ -1245,15 +1236,6 @@ interface ResizableHandleProps extends SeparatorProps$1 {
 }
 declare const ResizableHandle: ({ withHandle, className, ...props }: ResizableHandleProps) => react_jsx_runtime.JSX.Element;
 
-declare const dotsVariants: (props?: ({
-    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface DotsProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof dotsVariants> {
-    /** Number of dots to display */
-    count?: 3 | 4 | 5;
-}
-declare const Dots: React$1.ForwardRefExoticComponent<DotsProps & React$1.RefAttributes<HTMLSpanElement>>;
-
 declare const circularProgressVariants: (props?: ({
     size?: "sm" | "md" | "lg" | "xl" | null | undefined;
     color?: "default" | "success" | "warning" | "danger" | "primary" | null | undefined;
@@ -2700,28 +2682,6 @@ interface CloseButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElemen
 }
 declare const CloseButton: React$1.ForwardRefExoticComponent<CloseButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const actionIconVariants: (props?: ({
-    variant?: "solid" | "ghost" | "outline" | "soft" | "surface" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-    color?: "default" | "success" | "warning" | "danger" | "primary" | "secondary" | null | undefined;
-    radius?: "none" | "sm" | "md" | "lg" | "full" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface ActionIconProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "color">, VariantProps<typeof actionIconVariants> {
-    /** Loading state */
-    loading?: boolean;
-}
-declare const ActionIcon: React$1.ForwardRefExoticComponent<ActionIconProps & React$1.RefAttributes<HTMLButtonElement>>;
-
-interface PortalProps {
-    /** Content to render in the portal */
-    children: React$1.ReactNode;
-    /** Target container element or selector */
-    container?: Element | string | null;
-    /** Whether the portal is disabled (renders inline) */
-    disabled?: boolean;
-}
-declare const Portal: React$1.FC<PortalProps>;
-
 declare const indicatorVariants: (props?: ({
     color?: "default" | "success" | "warning" | "danger" | "primary" | "secondary" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -2754,10 +2714,6 @@ interface ScrollShadowProps extends React$1.HTMLAttributes<HTMLDivElement>, Vari
 }
 declare const ScrollShadow: React$1.ForwardRefExoticComponent<ScrollShadowProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface VisuallyHiddenProps extends React$1.HTMLAttributes<HTMLSpanElement> {
-}
-declare const VisuallyHidden: React$1.ForwardRefExoticComponent<VisuallyHiddenProps & React$1.RefAttributes<HTMLSpanElement>>;
-
 declare const kbdVariants: (props?: ({
     variant?: "default" | "ghost" | "outline" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -2778,14 +2734,6 @@ declare function useKeyboardShortcut(keys: string | string[], callback: (e: Keyb
     preventDefault?: boolean;
 }): void;
 
-interface SpacerProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    /** Fixed size in pixels or CSS value */
-    size?: number | string;
-    /** Axis direction */
-    axis?: "horizontal" | "vertical" | "both";
-}
-declare const Spacer: React$1.ForwardRefExoticComponent<SpacerProps & React$1.RefAttributes<HTMLDivElement>>;
-
 declare const copyButtonVariants: (props?: ({
     variant?: "solid" | "default" | "ghost" | "outline" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -2845,7 +2793,13 @@ declare const FullCalendar: React$1.ForwardRefExoticComponent<FullCalendarProps
 declare const chartContainerVariants: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
+/** Base data point for charts with arbitrary keys */
 interface ChartDataPoint {
+    name: string;
+    [key: string]: string | number;
+}
+/** Data point for PieChart requiring a value property */
+interface PieChartDataPoint {
     name: string;
     value: number;
     [key: string]: string | number;
@@ -2893,7 +2847,7 @@ interface BarChartProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantP
 declare const BarChart: React$1.ForwardRefExoticComponent<BarChartProps & React$1.RefAttributes<HTMLDivElement>>;
 interface PieChartProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chartContainerVariants> {
     /** Data to display */
-    data: ChartDataPoint[];
+    data: PieChartDataPoint[];
     /** Data key for values */
     dataKey?: string;
     /** Name key for labels */
@@ -3371,19 +3325,6 @@ declare function useButtonGroup(): {
 };
 declare const ButtonGroup: React$1.ForwardRefExoticComponent<ButtonGroupProps & React$1.RefAttributes<HTMLDivElement>>;
 
-declare const iconButtonVariants: (props?: ({
-    variant?: "solid" | "ghost" | "outline" | "soft" | "surface" | null | undefined;
-    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
-    radius?: "none" | "sm" | "md" | "lg" | "full" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface IconButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof iconButtonVariants> {
-    /** Accessibility label */
-    "aria-label": string;
-    /** Loading state */
-    isLoading?: boolean;
-}
-declare const IconButton: React$1.ForwardRefExoticComponent<IconButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
-
 declare const actionGroupVariants: (props?: ({
     variant?: "default" | "compact" | "attached" | null | undefined;
     orientation?: "horizontal" | "vertical" | null | undefined;
@@ -3478,45 +3419,6 @@ declare const ActionBarButton: React$1.ForwardRefExoticComponent<React$1.ButtonH
     icon?: React$1.ReactNode;
 } & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const actionMenuTriggerVariants: (props?: ({
-    variant?: "ghost" | "outline" | "subtle" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface ActionMenuItem {
-    key: string;
-    label: string;
-    icon?: React$1.ReactNode;
-    shortcut?: string;
-    isDisabled?: boolean;
-    isDestructive?: boolean;
-    onSelect?: () => void;
-}
-interface ActionMenuGroup {
-    key: string;
-    items: ActionMenuItem[];
-}
-interface ActionMenuProps extends VariantProps<typeof actionMenuTriggerVariants> {
-    /** Menu items or groups */
-    items: (ActionMenuItem | ActionMenuGroup)[];
-    /** Menu alignment */
-    align?: "start" | "center" | "end";
-    /** Menu side */
-    side?: "top" | "right" | "bottom" | "left";
-    /** Icon orientation */
-    iconOrientation?: "horizontal" | "vertical";
-    /** Custom trigger */
-    trigger?: React$1.ReactNode;
-    /** Called when an item is selected */
-    onAction?: (key: string) => void;
-    /** Trigger aria-label */
-    "aria-label"?: string;
-    /** Additional trigger className */
-    triggerClassName?: string;
-    /** Disabled state */
-    disabled?: boolean;
-}
-declare const ActionMenu: React$1.ForwardRefExoticComponent<ActionMenuProps & React$1.RefAttributes<HTMLButtonElement>>;
-
 declare const listViewVariants: (props?: ({
     variant?: "bordered" | "default" | "cards" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -3847,74 +3749,6 @@ interface ColorWheelProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "
 }
 declare const ColorWheel: React$1.ForwardRefExoticComponent<ColorWheelProps & React$1.RefAttributes<HTMLDivElement>>;
 
-declare const flexVariants: (props?: ({
-    direction?: "row" | "column" | "column-reverse" | "row-reverse" | null | undefined;
-    align?: "end" | "center" | "stretch" | "start" | "baseline" | null | undefined;
-    justify?: "end" | "center" | "start" | "between" | "around" | "evenly" | null | undefined;
-    wrap?: "nowrap" | "wrap" | "wrap-reverse" | null | undefined;
-    gap?: 0 | 1 | 2 | 3 | 4 | 8 | 5 | 6 | 10 | 12 | null | undefined;
-    inline?: boolean | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface FlexProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof flexVariants> {
-    /** Element to render as */
-    as?: React$1.ElementType;
-}
-declare const Flex: React$1.ForwardRefExoticComponent<FlexProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const HStack: React$1.ForwardRefExoticComponent<Omit<FlexProps, "direction"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const VStack: React$1.ForwardRefExoticComponent<Omit<FlexProps, "direction"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const Center: React$1.ForwardRefExoticComponent<Omit<FlexProps, "justify" | "align"> & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const gridVariants: (props?: ({
-    columns?: "none" | 1 | 2 | "auto" | 3 | 4 | 8 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | null | undefined;
-    rows?: "none" | 1 | 2 | 3 | 4 | 5 | 6 | null | undefined;
-    gap?: 0 | 1 | 2 | 3 | 4 | 8 | 5 | 6 | 10 | 12 | null | undefined;
-    gapX?: 0 | 1 | 2 | 3 | 4 | 8 | 5 | 6 | 10 | 12 | null | undefined;
-    gapY?: 0 | 1 | 2 | 3 | 4 | 8 | 5 | 6 | 10 | 12 | null | undefined;
-    flow?: "row" | "col" | "dense" | "row-dense" | "col-dense" | null | undefined;
-    align?: "end" | "center" | "stretch" | "start" | "baseline" | null | undefined;
-    justify?: "end" | "center" | "stretch" | "start" | null | undefined;
-    placeItems?: "end" | "center" | "stretch" | "start" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface GridProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof gridVariants> {
-    /** Element to render as */
-    as?: React$1.ElementType;
-    /** Min column width for auto columns */
-    minChildWidth?: string;
-}
-declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const gridItemVariants: (props?: ({
-    colSpan?: "full" | 1 | 2 | 3 | 4 | 8 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | null | undefined;
-    rowSpan?: "full" | 1 | 2 | 3 | 4 | 5 | 6 | null | undefined;
-    colStart?: 1 | 2 | "auto" | 3 | 4 | 8 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | null | undefined;
-    colEnd?: 1 | 2 | "auto" | 3 | 4 | 8 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | null | undefined;
-    rowStart?: 1 | 2 | "auto" | 3 | 4 | 5 | 6 | 7 | null | undefined;
-    rowEnd?: 1 | 2 | "auto" | 3 | 4 | 5 | 6 | 7 | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface GridItemProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof gridItemVariants> {
-    /** Element to render as */
-    as?: React$1.ElementType;
-}
-declare const GridItem: React$1.ForwardRefExoticComponent<GridItemProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const SimpleGrid: React$1.ForwardRefExoticComponent<Omit<GridProps, "columns"> & {
-    columns?: number | {
-        sm?: number;
-        md?: number;
-        lg?: number;
-        xl?: number;
-    };
-} & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const wellVariants: (props?: ({
-    variant?: "default" | "filled" | "outline" | "subtle" | "sunken" | null | undefined;
-    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
-    radius?: "none" | "sm" | "md" | "lg" | "full" | "xl" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface WellProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof wellVariants> {
-    /** Element to render as */
-    as?: React$1.ElementType;
-}
-declare const Well: React$1.ForwardRefExoticComponent<WellProps & React$1.RefAttributes<HTMLDivElement>>;
-
 declare const labeledValueVariants: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -4299,148 +4133,6 @@ interface PullToRefreshProps extends React$1.HTMLAttributes<HTMLDivElement>, Var
 }
 declare const PullToRefresh: React$1.ForwardRefExoticComponent<PullToRefreshProps & React$1.RefAttributes<HTMLDivElement>>;
 
-declare const appShellVariants: (props?: ({
-    layout?: "default" | "sidebar" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface AppShellProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof appShellVariants> {
-    /** Fixed header that stays at top */
-    header?: React$1.ReactNode;
-    /** Fixed footer that stays at bottom */
-    footer?: React$1.ReactNode;
-    /** Sidebar content (left side) */
-    sidebar?: React$1.ReactNode;
-    /** Right sidebar content */
-    aside?: React$1.ReactNode;
-    /** Whether sidebar is collapsed */
-    sidebarCollapsed?: boolean;
-    /** Width of sidebar when expanded */
-    sidebarWidth?: string;
-    /** Width of sidebar when collapsed */
-    sidebarCollapsedWidth?: string;
-    /** Width of aside */
-    asideWidth?: string;
-    /** Whether the layout is fixed (header/footer stick) */
-    fixed?: boolean;
-}
-declare const AppShell: React$1.ForwardRefExoticComponent<AppShellProps & React$1.RefAttributes<HTMLDivElement>>;
-interface AppShellHeaderProps extends React$1.HTMLAttributes<HTMLElement> {
-    fixed?: boolean;
-    hasSidebar?: boolean;
-}
-declare const AppShellHeader: React$1.ForwardRefExoticComponent<AppShellHeaderProps & React$1.RefAttributes<HTMLElement>>;
-interface AppShellSidebarProps extends React$1.HTMLAttributes<HTMLElement> {
-    collapsed?: boolean;
-    fixed?: boolean;
-}
-declare const AppShellSidebar: React$1.ForwardRefExoticComponent<AppShellSidebarProps & React$1.RefAttributes<HTMLElement>>;
-interface AppShellAsideProps extends React$1.HTMLAttributes<HTMLElement> {
-    fixed?: boolean;
-}
-declare const AppShellAside: React$1.ForwardRefExoticComponent<AppShellAsideProps & React$1.RefAttributes<HTMLElement>>;
-interface AppShellFooterProps extends React$1.HTMLAttributes<HTMLElement> {
-    fixed?: boolean;
-    hasSidebar?: boolean;
-}
-declare const AppShellFooter: React$1.ForwardRefExoticComponent<AppShellFooterProps & React$1.RefAttributes<HTMLElement>>;
-declare const AppShellMain: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const dashboardLayoutVariants: (props?: ({
-    variant?: "bordered" | "default" | "filled" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface DashboardLayoutProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof dashboardLayoutVariants> {
-    /** Navigation items for sidebar */
-    navigation?: React$1.ReactNode;
-    /** Logo/brand element */
-    logo?: React$1.ReactNode;
-    /** User menu/profile element */
-    userMenu?: React$1.ReactNode;
-    /** Header actions (notifications, etc) */
-    headerActions?: React$1.ReactNode;
-    /** Breadcrumb element */
-    breadcrumb?: React$1.ReactNode;
-    /** Default collapsed state */
-    defaultCollapsed?: boolean;
-    /** Controlled collapsed state */
-    collapsed?: boolean;
-    /** Callback when collapsed state changes */
-    onCollapsedChange?: (collapsed: boolean) => void;
-}
-declare const DashboardLayout: React$1.ForwardRefExoticComponent<DashboardLayoutProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const DashboardPage: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
-interface DashboardPageHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    title?: string;
-    description?: string;
-    actions?: React$1.ReactNode;
-}
-declare const DashboardPageHeader: React$1.ForwardRefExoticComponent<DashboardPageHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const DashboardGrid: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
-    columns?: 1 | 2 | 3 | 4;
-} & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const authLayoutVariants: (props?: ({
-    variant?: "split" | "cover" | "centered" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface AuthLayoutProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof authLayoutVariants> {
-    /** Logo element */
-    logo?: React$1.ReactNode;
-    /** Side panel content (for split variant) */
-    sideContent?: React$1.ReactNode;
-    /** Background image URL (for cover variant) */
-    backgroundImage?: string;
-    /** Side panel position */
-    sidePosition?: "left" | "right";
-    /** Footer content */
-    footer?: React$1.ReactNode;
-}
-declare const AuthLayout: React$1.ForwardRefExoticComponent<AuthLayoutProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const AuthForm: React$1.ForwardRefExoticComponent<React$1.FormHTMLAttributes<HTMLFormElement> & React$1.RefAttributes<HTMLFormElement>>;
-interface AuthHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    title?: string;
-    description?: string;
-}
-declare const AuthHeader: React$1.ForwardRefExoticComponent<AuthHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const AuthFooterLinks: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
-declare const AuthDivider: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
-    text?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const AuthSocialButtons: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const settingsLayoutVariants: (props?: ({
-    variant?: "sidebar" | "stacked" | "tabs" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface SettingsLayoutProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof settingsLayoutVariants> {
-    /** Navigation element (sidebar or tabs) */
-    navigation?: React$1.ReactNode;
-    /** Page title */
-    title?: string;
-    /** Page description */
-    description?: string;
-}
-declare const SettingsLayout: React$1.ForwardRefExoticComponent<SettingsLayoutProps & React$1.RefAttributes<HTMLDivElement>>;
-interface SettingsHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    title?: string;
-    description?: string;
-}
-declare const SettingsHeader: React$1.ForwardRefExoticComponent<SettingsHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
-interface SettingsSectionProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    title?: string;
-    description?: string;
-}
-declare const SettingsSection: React$1.ForwardRefExoticComponent<SettingsSectionProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const SettingsCard: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
-interface SettingsRowProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    label?: string;
-    description?: string;
-    htmlFor?: string;
-}
-declare const SettingsRow: React$1.ForwardRefExoticComponent<SettingsRowProps & React$1.RefAttributes<HTMLDivElement>>;
-interface SettingsNavItemProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
-    active?: boolean;
-    icon?: React$1.ReactNode;
-}
-declare const SettingsNavItem: React$1.ForwardRefExoticComponent<SettingsNavItemProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SettingsSeparator: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
-
 interface TransitionProps {
     /** Whether the component is visible */
     show?: boolean;
@@ -4943,10 +4635,2660 @@ interface ULProps extends React$1.HTMLAttributes<HTMLUListElement> {
 }
 declare const UL: React$1.ForwardRefExoticComponent<ULProps & React$1.RefAttributes<HTMLUListElement>>;
 
+/**
+ * Hook to detect if a media query matches
+ * @param query - CSS media query string (e.g., "(min-width: 768px)")
+ * @returns boolean indicating if the media query matches
+ *
+ * @example
+ * ```tsx
+ * const isMobile = useMediaQuery("(max-width: 767px)");
+ * const isTablet = useMediaQuery("(min-width: 768px) and (max-width: 1023px)");
+ * const isDesktop = useMediaQuery("(min-width: 1024px)");
+ * const prefersDark = useMediaQuery("(prefers-color-scheme: dark)");
+ * ```
+ */
+declare function useMediaQuery(query: string): boolean;
+declare function useIsMobile(): boolean;
+declare function useIsTablet(): boolean;
+declare function useIsDesktop(): boolean;
+declare function usePrefersColorScheme(): "light" | "dark";
+declare function usePrefersReducedMotion(): boolean;
+
+interface WindowSize {
+    width: number;
+    height: number;
+}
+interface UseWindowSizeOptions {
+    /** Initial width for SSR (default: 0) */
+    initialWidth?: number;
+    /** Initial height for SSR (default: 0) */
+    initialHeight?: number;
+    /** Debounce delay in ms (default: 0) */
+    debounce?: number;
+    /** Whether to include scrollbar in measurements (default: true) */
+    includeScrollbar?: boolean;
+}
+/**
+ * Hook to track window size
+ * @param options - configuration options
+ * @returns current window width and height
+ *
+ * @example
+ * ```tsx
+ * function ResponsiveComponent() {
+ *   const { width, height } = useWindowSize();
+ *
+ *   return (
+ *     <div>
+ *       Window size: {width} x {height}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useWindowSize(options?: UseWindowSizeOptions): WindowSize;
+/**
+ * Hook to get window width only
+ * @returns window width
+ *
+ * @example
+ * ```tsx
+ * const width = useWindowWidth();
+ * const columns = width > 1024 ? 4 : width > 768 ? 3 : 2;
+ * ```
+ */
+declare function useWindowWidth(): number;
+/**
+ * Hook to get window height only
+ * @returns window height
+ *
+ * @example
+ * ```tsx
+ * const height = useWindowHeight();
+ * const rowHeight = height > 800 ? 60 : 40;
+ * ```
+ */
+declare function useWindowHeight(): number;
+/**
+ * Hook to check if window matches a breakpoint
+ * @param breakpoint - min-width breakpoint value
+ * @returns whether window width is >= breakpoint
+ *
+ * @example
+ * ```tsx
+ * const isLargeScreen = useBreakpoint(1024);
+ * ```
+ */
+declare function useBreakpoint(breakpoint: number): boolean;
+/**
+ * Hook for responsive breakpoints
+ * @returns object with common breakpoint checks
+ *
+ * @example
+ * ```tsx
+ * const { isSm, isMd, isLg, isXl, is2xl } = useBreakpoints();
+ * ```
+ */
+declare function useBreakpoints(): {
+    isSm: boolean;
+    isMd: boolean;
+    isLg: boolean;
+    isXl: boolean;
+    is2xl: boolean;
+};
+
+type SetValue$1<T> = T | ((prevValue: T) => T);
+/**
+ * Hook to sync state with localStorage
+ * @param key - localStorage key
+ * @param initialValue - initial value if key doesn't exist
+ * @returns [value, setValue, removeValue] tuple
+ *
+ * @example
+ * ```tsx
+ * const [theme, setTheme, removeTheme] = useLocalStorage("theme", "light");
+ * const [user, setUser] = useLocalStorage<User | null>("user", null);
+ * ```
+ */
+declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: SetValue$1<T>) => void, () => void];
+
+type SetValue<T> = T | ((prevValue: T) => T);
+/**
+ * Hook to sync state with sessionStorage
+ * @param key - sessionStorage key
+ * @param initialValue - initial value if key doesn't exist
+ * @returns [value, setValue, removeValue] tuple
+ *
+ * @example
+ * ```tsx
+ * const [formData, setFormData] = useSessionStorage("checkout-form", {});
+ * const [step, setStep, resetStep] = useSessionStorage("wizard-step", 0);
+ * ```
+ */
+declare function useSessionStorage<T>(key: string, initialValue: T): [T, (value: SetValue<T>) => void, () => void];
+
+/**
+ * Hook to debounce a value
+ * @param value - value to debounce
+ * @param delay - delay in milliseconds (default: 500ms)
+ * @returns debounced value
+ *
+ * @example
+ * ```tsx
+ * const [searchTerm, setSearchTerm] = useState("");
+ * const debouncedSearch = useDebounce(searchTerm, 300);
+ *
+ * useEffect(() => {
+ *   // This will only run 300ms after user stops typing
+ *   fetchSearchResults(debouncedSearch);
+ * }, [debouncedSearch]);
+ * ```
+ */
+declare function useDebounce<T>(value: T, delay?: number): T;
+
+/**
+ * Hook to debounce a callback function
+ * @param callback - function to debounce
+ * @param delay - delay in milliseconds (default: 500ms)
+ * @returns debounced callback
+ *
+ * @example
+ * ```tsx
+ * const debouncedSave = useDebouncedCallback((data) => {
+ *   saveToServer(data);
+ * }, 1000);
+ *
+ * // This will only call saveToServer 1 second after last call
+ * <input onChange={(e) => debouncedSave(e.target.value)} />
+ * ```
+ */
+declare function useDebouncedCallback<T extends (...args: unknown[]) => unknown>(callback: T, delay?: number): (...args: Parameters<T>) => void;
+/**
+ * Hook to debounce a callback with cancel and flush capabilities
+ */
+declare function useDebouncedCallbackWithControls<T extends (...args: unknown[]) => unknown>(callback: T, delay?: number): {
+    debouncedCallback: (...args: Parameters<T>) => void;
+    cancel: () => void;
+    flush: () => void;
+    isPending: () => boolean;
+};
+
+/**
+ * Hook to throttle a value
+ * @param value - value to throttle
+ * @param interval - throttle interval in milliseconds (default: 500ms)
+ * @returns throttled value
+ *
+ * @example
+ * ```tsx
+ * const [mousePosition, setMousePosition] = useState({ x: 0, y: 0 });
+ * const throttledPosition = useThrottle(mousePosition, 100);
+ *
+ * // throttledPosition updates at most every 100ms
+ * ```
+ */
+declare function useThrottle<T>(value: T, interval?: number): T;
+/**
+ * Hook to throttle a callback function
+ * @param callback - function to throttle
+ * @param interval - throttle interval in milliseconds (default: 500ms)
+ * @returns throttled callback
+ *
+ * @example
+ * ```tsx
+ * const throttledScroll = useThrottledCallback((e) => {
+ *   console.log("Scroll position:", window.scrollY);
+ * }, 100);
+ *
+ * useEffect(() => {
+ *   window.addEventListener("scroll", throttledScroll);
+ *   return () => window.removeEventListener("scroll", throttledScroll);
+ * }, [throttledScroll]);
+ * ```
+ */
+declare function useThrottledCallback<T extends (...args: unknown[]) => unknown>(callback: T, interval?: number): (...args: Parameters<T>) => void;
+
+type Handler = (event: MouseEvent | TouchEvent) => void;
+/**
+ * Hook to detect clicks outside of an element
+ * @param handler - callback when click outside is detected
+ * @param enabled - whether the hook is enabled (default: true)
+ * @returns ref to attach to the element
+ *
+ * @example
+ * ```tsx
+ * function Dropdown() {
+ *   const [isOpen, setIsOpen] = useState(false);
+ *   const ref = useClickOutside(() => setIsOpen(false));
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <button onClick={() => setIsOpen(true)}>Open</button>
+ *       {isOpen && <div>Dropdown content</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useClickOutside<T extends HTMLElement = HTMLElement>(handler: Handler, enabled?: boolean): RefObject<T | null>;
+/**
+ * Hook to detect clicks outside of multiple elements
+ * @param refs - array of refs to check
+ * @param handler - callback when click outside is detected
+ * @param enabled - whether the hook is enabled (default: true)
+ *
+ * @example
+ * ```tsx
+ * function Menu() {
+ *   const buttonRef = useRef<HTMLButtonElement>(null);
+ *   const menuRef = useRef<HTMLDivElement>(null);
+ *
+ *   useClickOutsideMultiple([buttonRef, menuRef], () => setIsOpen(false));
+ *
+ *   return (
+ *     <>
+ *       <button ref={buttonRef}>Toggle</button>
+ *       <div ref={menuRef}>Menu content</div>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useClickOutsideMultiple<T extends HTMLElement = HTMLElement>(refs: RefObject<T | null>[], handler: Handler, enabled?: boolean): void;
+
+interface UseCopyToClipboardResult {
+    /** The copied value */
+    copiedValue: string | null;
+    /** Whether the copy was successful */
+    success: boolean;
+    /** Whether a copy operation is in progress */
+    isLoading: boolean;
+    /** Copy text to clipboard */
+    copy: (text: string) => Promise<boolean>;
+    /** Reset the copied state */
+    reset: () => void;
+}
+/**
+ * Hook to copy text to clipboard
+ * @param resetDelay - delay in ms before resetting success state (default: 2000, set to 0 to disable)
+ * @returns object with copy function and state
+ *
+ * @example
+ * ```tsx
+ * function CopyButton({ text }: { text: string }) {
+ *   const { copy, success, copiedValue } = useCopyToClipboard();
+ *
+ *   return (
+ *     <button onClick={() => copy(text)}>
+ *       {success ? "Copied!" : "Copy"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCopyToClipboard(resetDelay?: number): UseCopyToClipboardResult;
+/**
+ * Simple hook that just returns a copy function
+ * @returns copy function
+ *
+ * @example
+ * ```tsx
+ * const copyToClipboard = useCopy();
+ * <button onClick={() => copyToClipboard("Hello!")}>Copy</button>
+ * ```
+ */
+declare function useCopy(): (text: string) => Promise<boolean>;
+
+type KeyHandler = (event: KeyboardEvent) => void;
+interface HotkeyOptions {
+    /** Whether the hotkey is enabled (default: true) */
+    enabled?: boolean;
+    /** Whether to prevent default browser behavior (default: true) */
+    preventDefault?: boolean;
+    /** Whether to stop event propagation (default: false) */
+    stopPropagation?: boolean;
+    /** Target element (default: document) */
+    target?: HTMLElement | null;
+    /** Only trigger when these modifiers are pressed */
+    modifiers?: {
+        ctrl?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+        meta?: boolean;
+    };
+}
+/**
+ * Hook to handle keyboard shortcuts
+ * @param hotkey - keyboard shortcut (e.g., "ctrl+k", "cmd+shift+p", "escape")
+ * @param handler - callback when hotkey is pressed
+ * @param options - configuration options
+ *
+ * @example
+ * ```tsx
+ * // Single hotkey
+ * useHotkeys("ctrl+k", () => setSearchOpen(true));
+ *
+ * // With options
+ * useHotkeys("escape", () => closeModal(), { enabled: isModalOpen });
+ *
+ * // Mac command key (meta)
+ * useHotkeys("cmd+s", () => saveDocument(), { preventDefault: true });
+ * ```
+ */
+declare function useHotkeys(hotkey: string, handler: KeyHandler, options?: HotkeyOptions): void;
+/**
+ * Hook to handle multiple keyboard shortcuts
+ * @param hotkeys - map of hotkey to handler
+ * @param options - shared configuration options
+ *
+ * @example
+ * ```tsx
+ * useHotkeysMap({
+ *   "ctrl+k": () => openSearch(),
+ *   "ctrl+b": () => toggleBold(),
+ *   "ctrl+i": () => toggleItalic(),
+ *   "escape": () => closeModal(),
+ * });
+ * ```
+ */
+declare function useHotkeysMap(hotkeys: Record<string, KeyHandler>, options?: HotkeyOptions): void;
+/**
+ * Hook to check if a specific key is currently pressed
+ * @param key - key to check
+ * @returns whether the key is pressed
+ *
+ * @example
+ * ```tsx
+ * const isShiftPressed = useKeyPressed("Shift");
+ * ```
+ */
+declare function useKeyPressed(key: string): boolean;
+
+/**
+ * Hook to add event listener to window/document/element
+ * @param eventName - event name
+ * @param handler - event handler
+ * @param element - target element (default: window)
+ * @param options - addEventListener options
+ *
+ * @example
+ * ```tsx
+ * // Window event
+ * function KeyboardListener() {
+ *   useEventListener('keydown', (event) => {
+ *     console.log('Key pressed:', event.key);
+ *   });
+ *
+ *   return <div>Press any key</div>;
+ * }
+ *
+ * // Element event
+ * function ClickTracker() {
+ *   const ref = useRef<HTMLButtonElement>(null);
+ *
+ *   useEventListener('click', (event) => {
+ *     console.log('Button clicked!');
+ *   }, ref);
+ *
+ *   return <button ref={ref}>Click me</button>;
+ * }
+ * ```
+ */
+declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: Document | null, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = HTMLElement>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, element: RefObject<T | null>, options?: boolean | AddEventListenerOptions): void;
+/**
+ * Hook to add event listener with element ref
+ * @param eventName - event name
+ * @param handler - event handler
+ * @param options - addEventListener options
+ * @returns ref to attach to element
+ *
+ * @example
+ * ```tsx
+ * function ClickTracker() {
+ *   const ref = useEventListenerRef<HTMLButtonElement>('click', () => {
+ *     console.log('Button clicked!');
+ *   });
+ *
+ *   return <button ref={ref}>Click me</button>;
+ * }
+ * ```
+ */
+declare function useEventListenerRef<T extends HTMLElement = HTMLElement>(eventName: string, handler: (event: Event) => void, options?: boolean | AddEventListenerOptions): RefObject<T | null>;
+/**
+ * Hook to run callback when specific key is pressed
+ * @param key - key to listen for
+ * @param callback - function to call when key is pressed
+ * @param options - configuration options
+ *
+ * @example
+ * ```tsx
+ * function SearchShortcut() {
+ *   useKeyPress('/', () => openSearch());
+ *   useKeyPress('Escape', () => closeSearch());
+ * }
+ * ```
+ */
+declare function useKeyPress(key: string, callback: (event: KeyboardEvent) => void, options?: {
+    target?: RefObject<HTMLElement | null>;
+    event?: "keydown" | "keyup" | "keypress";
+    enabled?: boolean;
+}): void;
+
+interface LongPressOptions {
+    /** Duration in ms before long press triggers (default: 500) */
+    threshold?: number;
+    /** Callback when long press starts */
+    onStart?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback when long press ends (before threshold) */
+    onCancel?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Whether the hook is enabled (default: true) */
+    enabled?: boolean;
+}
+interface LongPressResult {
+    onMouseDown: (event: React.MouseEvent) => void;
+    onMouseUp: (event: React.MouseEvent) => void;
+    onMouseLeave: (event: React.MouseEvent) => void;
+    onTouchStart: (event: React.TouchEvent) => void;
+    onTouchEnd: (event: React.TouchEvent) => void;
+}
+/**
+ * Hook to detect long press gestures
+ * @param callback - function called when long press is detected
+ * @param options - configuration options
+ * @returns event handlers to spread on target element
+ *
+ * @example
+ * ```tsx
+ * function DeleteButton() {
+ *   const longPressProps = useLongPress(
+ *     () => deleteItem(),
+ *     { threshold: 1000 }
+ *   );
+ *
+ *   return (
+ *     <button {...longPressProps}>
+ *       Hold to delete
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useLongPress(callback: (event: React.MouseEvent | React.TouchEvent) => void, options?: LongPressOptions): LongPressResult;
+
+interface HoverCallbacks {
+    onHoverStart?: () => void;
+    onHoverEnd?: () => void;
+}
+/**
+ * Hook to detect hover state
+ * @param callbacks - optional callbacks for hover start/end
+ * @returns ref and hover state
+ *
+ * @example
+ * ```tsx
+ * function HoverCard() {
+ *   const { ref, isHovered } = useHover<HTMLDivElement>();
+ *
+ *   return (
+ *     <div
+ *       ref={ref}
+ *       className={isHovered ? 'shadow-lg scale-105' : ''}
+ *     >
+ *       Card content
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useHover<T extends HTMLElement = HTMLElement>(callbacks?: HoverCallbacks): {
+    ref: RefObject<T | null>;
+    isHovered: boolean;
+};
+/**
+ * Hook to detect hover state on existing ref
+ * @param ref - element ref
+ * @param callbacks - optional callbacks
+ * @returns whether element is hovered
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const buttonRef = useRef<HTMLButtonElement>(null);
+ *   const isHovered = useHoverRef(buttonRef);
+ *
+ *   return <button ref={buttonRef}>Hover me</button>;
+ * }
+ * ```
+ */
+declare function useHoverRef<T extends HTMLElement>(ref: RefObject<T | null>, callbacks?: HoverCallbacks): boolean;
+/**
+ * Returns props to spread on element for hover detection
+ * @returns hover state and event handlers
+ *
+ * @example
+ * ```tsx
+ * function Button() {
+ *   const { isHovered, hoverProps } = useHoverProps();
+ *
+ *   return (
+ *     <button {...hoverProps} className={isHovered ? 'bg-blue-600' : 'bg-blue-500'}>
+ *       Hover me
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useHoverProps(): {
+    isHovered: boolean;
+    hoverProps: {
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+};
+/**
+ * Hook to detect hover with delay
+ * @param delay - delay in ms before hover state changes
+ * @returns ref and hover state
+ *
+ * @example
+ * ```tsx
+ * function Tooltip() {
+ *   const { ref, isHovered } = useHoverDelay<HTMLSpanElement>(300);
+ *
+ *   return (
+ *     <span ref={ref}>
+ *       Hover for tooltip
+ *       {isHovered && <div className="tooltip">Content</div>}
+ *     </span>
+ *   );
+ * }
+ * ```
+ */
+declare function useHoverDelay<T extends HTMLElement = HTMLElement>(delay?: number): {
+    ref: RefObject<T | null>;
+    isHovered: boolean;
+};
+
+interface MousePosition {
+    x: number;
+    y: number;
+    elementX: number;
+    elementY: number;
+    elementPositionX: number;
+    elementPositionY: number;
+    pageX: number;
+    pageY: number;
+}
+interface UseMouseOptions {
+    /** Whether to track mouse (default: true) */
+    enabled?: boolean;
+    /** Reset position when mouse leaves (default: false) */
+    resetOnLeave?: boolean;
+}
+/**
+ * Hook to track mouse position relative to window
+ * @returns mouse position coordinates
+ *
+ * @example
+ * ```tsx
+ * function Cursor() {
+ *   const { x, y } = useMouse();
+ *
+ *   return (
+ *     <div
+ *       className="custom-cursor"
+ *       style={{ left: x, top: y }}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useMouse(): {
+    x: number;
+    y: number;
+};
+/**
+ * Hook to track mouse position relative to an element
+ * @param options - configuration options
+ * @returns ref and mouse position
+ *
+ * @example
+ * ```tsx
+ * function Canvas() {
+ *   const { ref, x, y, elementX, elementY } = useMouseElement<HTMLDivElement>();
+ *
+ *   return (
+ *     <div ref={ref} className="canvas">
+ *       Position in canvas: {elementX}, {elementY}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMouseElement<T extends HTMLElement = HTMLElement>(options?: UseMouseOptions): MousePosition & {
+    ref: RefObject<T | null>;
+};
+/**
+ * Hook to track mouse position on existing ref
+ * @param ref - element ref
+ * @param options - configuration options
+ * @returns mouse position
+ */
+declare function useMouseElementRef<T extends HTMLElement>(ref: RefObject<T | null>, options?: UseMouseOptions): MousePosition;
+
+interface UseFocusTrapOptions {
+    /** Whether the trap is active (default: true) */
+    enabled?: boolean;
+    /** Element to focus initially */
+    initialFocus?: RefObject<HTMLElement | null>;
+    /** Element to focus when trap is deactivated */
+    returnFocus?: boolean;
+    /** Whether to auto-focus first focusable element (default: true) */
+    autoFocus?: boolean;
+}
+/**
+ * Hook to trap focus within an element
+ * @param options - configuration options
+ * @returns ref to attach to trap container
+ *
+ * @example
+ * ```tsx
+ * function Modal({ isOpen }) {
+ *   const focusTrapRef = useFocusTrap<HTMLDivElement>({
+ *     enabled: isOpen,
+ *     returnFocus: true,
+ *   });
+ *
+ *   return (
+ *     <div ref={focusTrapRef} role="dialog">
+ *       <input placeholder="First input" />
+ *       <button>Action</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFocusTrap<T extends HTMLElement = HTMLElement>(options?: UseFocusTrapOptions): RefObject<T | null>;
+/**
+ * Hook to trap focus with existing ref
+ * @param ref - container ref
+ * @param options - configuration options
+ */
+declare function useFocusTrapRef<T extends HTMLElement>(ref: RefObject<T | null>, options?: UseFocusTrapOptions): void;
+
+interface ScrollPosition {
+    x: number;
+    y: number;
+}
+interface ScrollInfo extends ScrollPosition {
+    /** Whether scrolled past the top threshold */
+    isScrolled: boolean;
+    /** Scroll direction (1 = down/right, -1 = up/left, 0 = initial) */
+    directionY: -1 | 0 | 1;
+    directionX: -1 | 0 | 1;
+    /** Whether at the bottom of the page/element */
+    isAtBottom: boolean;
+    /** Whether at the top of the page/element */
+    isAtTop: boolean;
+    /** Scroll progress (0-1) */
+    progress: number;
+}
+interface UseScrollPositionOptions {
+    /** Threshold for isScrolled state (default: 0) */
+    threshold?: number;
+    /** Throttle delay in ms (default: 0) */
+    throttle?: number;
+    /** Element ref to track (default: window) */
+    element?: RefObject<HTMLElement | null>;
+}
+/**
+ * Hook to track scroll position
+ * @param options - configuration options
+ * @returns scroll position and related info
+ *
+ * @example
+ * ```tsx
+ * function Header() {
+ *   const { isScrolled, y, directionY } = useScrollPosition({ threshold: 100 });
+ *
+ *   return (
+ *     <header className={isScrolled ? 'shadow-lg' : ''}>
+ *       {directionY === -1 && <BackToTop />}
+ *     </header>
+ *   );
+ * }
+ * ```
+ */
+declare function useScrollPosition(options?: UseScrollPositionOptions): ScrollInfo;
+/**
+ * Simple hook to get window scroll position
+ * @returns x and y scroll coordinates
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const { x, y } = useWindowScroll();
+ *   return <div>Scroll: {y}px</div>;
+ * }
+ * ```
+ */
+declare function useWindowScroll(): ScrollPosition;
+
+interface ScrollLockOptions {
+    /** Whether to lock scroll initially (default: false) */
+    autoLock?: boolean;
+    /** Lock horizontal scroll too (default: true) */
+    lockX?: boolean;
+}
+interface ScrollLockReturn {
+    /** Lock the scroll */
+    lock: () => void;
+    /** Unlock the scroll */
+    unlock: () => void;
+    /** Whether scroll is currently locked */
+    isLocked: boolean;
+}
+/**
+ * Hook to lock/unlock body scroll
+ * @param options - configuration options
+ * @returns lock controls
+ *
+ * @example
+ * ```tsx
+ * function Modal({ isOpen }) {
+ *   const { lock, unlock } = useScrollLock();
+ *
+ *   useEffect(() => {
+ *     if (isOpen) lock();
+ *     else unlock();
+ *   }, [isOpen]);
+ *
+ *   return <div>Modal content</div>;
+ * }
+ * ```
+ */
+declare function useScrollLock(options?: ScrollLockOptions): ScrollLockReturn;
+/**
+ * Simpler hook that auto-locks when mounted
+ * @param enabled - whether to lock scroll (default: true)
+ *
+ * @example
+ * ```tsx
+ * function Modal({ isOpen }) {
+ *   useBodyScrollLock(isOpen);
+ *   return <div>Modal</div>;
+ * }
+ * ```
+ */
+declare function useBodyScrollLock(enabled?: boolean): void;
+
+interface UseIntersectionObserverOptions {
+    /** Root element for intersection (default: viewport) */
+    root?: Element | null;
+    /** Margin around root (default: "0px") */
+    rootMargin?: string;
+    /** Threshold(s) at which callback is invoked (default: 0) */
+    threshold?: number | number[];
+    /** Whether to disconnect after first intersection */
+    once?: boolean;
+    /** Whether observer is enabled (default: true) */
+    enabled?: boolean;
+}
+interface IntersectionResult {
+    /** Whether element is intersecting */
+    isIntersecting: boolean;
+    /** The IntersectionObserverEntry */
+    entry: IntersectionObserverEntry | null;
+}
+/**
+ * Hook to observe element intersection with viewport
+ * @param options - IntersectionObserver options
+ * @returns ref to attach and intersection state
+ *
+ * @example
+ * ```tsx
+ * function LazyImage({ src }) {
+ *   const { ref, isIntersecting } = useIntersectionObserver({
+ *     threshold: 0.1,
+ *     once: true,
+ *   });
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       {isIntersecting && <img src={src} />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useIntersectionObserver<T extends HTMLElement = HTMLElement>(options?: UseIntersectionObserverOptions): IntersectionResult & {
+    ref: RefObject<T | null>;
+};
+/**
+ * Hook to observe intersection with existing ref
+ * @param ref - ref to observe
+ * @param options - IntersectionObserver options
+ * @returns intersection state
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const containerRef = useRef<HTMLDivElement>(null);
+ *   const { isIntersecting } = useIntersectionObserverRef(containerRef, {
+ *     threshold: 0.5,
+ *   });
+ *
+ *   return <div ref={containerRef}>...</div>;
+ * }
+ * ```
+ */
+declare function useIntersectionObserverRef<T extends HTMLElement>(ref: RefObject<T | null>, options?: UseIntersectionObserverOptions): IntersectionResult;
+/**
+ * Hook for lazy loading (intersection triggers once)
+ * @param rootMargin - margin for early triggering
+ * @returns ref and whether visible
+ *
+ * @example
+ * ```tsx
+ * function LazySection() {
+ *   const { ref, isVisible } = useLazyLoad("100px");
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       {isVisible ? <HeavyComponent /> : <Placeholder />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useLazyLoad<T extends HTMLElement = HTMLElement>(rootMargin?: string): {
+    ref: RefObject<T | null>;
+    isVisible: boolean;
+};
+
+interface UseMutationObserverOptions extends MutationObserverInit {
+    /** Whether observer is enabled (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Hook to observe DOM mutations
+ * @param callback - function called on mutation
+ * @param options - MutationObserver options
+ * @returns ref to attach to target element
+ *
+ * @example
+ * ```tsx
+ * function LiveEditor() {
+ *   const ref = useMutationObserver(
+ *     (mutations) => {
+ *       console.log('DOM changed:', mutations);
+ *     },
+ *     { childList: true, subtree: true }
+ *   );
+ *
+ *   return <div ref={ref} contentEditable />;
+ * }
+ * ```
+ */
+declare function useMutationObserver<T extends HTMLElement = HTMLElement>(callback: MutationCallback, options?: UseMutationObserverOptions): RefObject<T | null>;
+/**
+ * Hook to observe DOM mutations on existing ref
+ * @param ref - ref to observe
+ * @param callback - function called on mutation
+ * @param options - MutationObserver options
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const containerRef = useRef<HTMLDivElement>(null);
+ *
+ *   useMutationObserverRef(
+ *     containerRef,
+ *     (mutations) => logChanges(mutations),
+ *     { childList: true }
+ *   );
+ *
+ *   return <div ref={containerRef}>...</div>;
+ * }
+ * ```
+ */
+declare function useMutationObserverRef<T extends HTMLElement>(ref: RefObject<T | null>, callback: MutationCallback, options?: UseMutationObserverOptions): void;
+
+interface Size {
+    width: number;
+    height: number;
+}
+interface UseResizeObserverOptions {
+    /** Whether observer is enabled (default: true) */
+    enabled?: boolean;
+    /** Box model to observe (default: "content-box") */
+    box?: "content-box" | "border-box" | "device-pixel-content-box";
+    /** Debounce delay in ms (default: 0) */
+    debounce?: number;
+}
+/**
+ * Hook to observe element size changes
+ * @param options - configuration options
+ * @returns ref and current size
+ *
+ * @example
+ * ```tsx
+ * function ResponsiveChart() {
+ *   const { ref, width, height } = useResizeObserver<HTMLDivElement>();
+ *
+ *   return (
+ *     <div ref={ref} className="w-full">
+ *       <Chart width={width} height={height} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useResizeObserver<T extends HTMLElement = HTMLElement>(options?: UseResizeObserverOptions): Size & {
+    ref: RefObject<T | null>;
+};
+/**
+ * Hook to observe size changes on existing ref
+ * @param ref - ref to observe
+ * @param options - configuration options
+ * @returns current size
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const containerRef = useRef<HTMLDivElement>(null);
+ *   const { width, height } = useResizeObserverRef(containerRef);
+ *
+ *   return <div ref={containerRef}>Size: {width}x{height}</div>;
+ * }
+ * ```
+ */
+declare function useResizeObserverRef<T extends HTMLElement>(ref: RefObject<T | null>, options?: UseResizeObserverOptions): Size;
+/**
+ * Hook to get element size (one-time measurement)
+ * @returns ref and size measuring function
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const { ref, measure } = useElementSize<HTMLDivElement>();
+ *
+ *   useEffect(() => {
+ *     const size = measure();
+ *     console.log('Size:', size);
+ *   }, []);
+ *
+ *   return <div ref={ref}>Content</div>;
+ * }
+ * ```
+ */
+declare function useElementSize<T extends HTMLElement = HTMLElement>(): {
+    ref: RefObject<T | null>;
+    measure: () => Size;
+};
+
+interface UseDisclosureReturn {
+    /** Whether the disclosure is open */
+    isOpen: boolean;
+    /** Open the disclosure */
+    open: () => void;
+    /** Close the disclosure */
+    close: () => void;
+    /** Toggle the disclosure */
+    toggle: () => void;
+    /** Set the disclosure state directly */
+    setIsOpen: (value: boolean) => void;
+    /** Props to spread on trigger element */
+    getButtonProps: () => {
+        onClick: () => void;
+        "aria-expanded": boolean;
+    };
+    /** Props to spread on disclosure panel */
+    getDisclosureProps: () => {
+        hidden: boolean;
+    };
+}
+interface UseDisclosureOptions {
+    /** Initial open state */
+    defaultOpen?: boolean;
+    /** Controlled open state */
+    isOpen?: boolean;
+    /** Callback when open state changes */
+    onOpen?: () => void;
+    /** Callback when close state changes */
+    onClose?: () => void;
+    /** Callback when state changes */
+    onChange?: (isOpen: boolean) => void;
+    /** ID for ARIA attributes */
+    id?: string;
+}
+/**
+ * Hook to manage open/close state for modals, dropdowns, etc.
+ * @param options - configuration options
+ * @returns disclosure state and controls
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * function Modal() {
+ *   const { isOpen, open, close, toggle } = useDisclosure();
+ *
+ *   return (
+ *     <>
+ *       <button onClick={open}>Open Modal</button>
+ *       {isOpen && (
+ *         <div>
+ *           Modal content
+ *           <button onClick={close}>Close</button>
+ *         </div>
+ *       )}
+ *     </>
+ *   );
+ * }
+ *
+ * // With spread props
+ * function Dropdown() {
+ *   const { isOpen, getButtonProps, getDisclosureProps } = useDisclosure();
+ *
+ *   return (
+ *     <>
+ *       <button {...getButtonProps()}>Toggle</button>
+ *       <div {...getDisclosureProps()}>Dropdown content</div>
+ *     </>
+ *   );
+ * }
+ *
+ * // Controlled
+ * function ControlledModal({ isOpen, onOpenChange }) {
+ *   const disclosure = useDisclosure({
+ *     isOpen,
+ *     onChange: onOpenChange,
+ *   });
+ * }
+ * ```
+ */
+declare function useDisclosure(options?: UseDisclosureOptions): UseDisclosureReturn;
+/**
+ * Shorthand for useDisclosure with initial open state
+ */
+declare function useDisclosureOpen(options?: Omit<UseDisclosureOptions, "defaultOpen">): UseDisclosureReturn;
+
+/**
+ * Hook to toggle a boolean value
+ * @param initialValue - initial boolean state (default: false)
+ * @returns tuple of [value, toggle, setValue]
+ *
+ * @example
+ * ```tsx
+ * function Toggle() {
+ *   const [isOn, toggle] = useToggle(false);
+ *
+ *   return (
+ *     <button onClick={toggle}>
+ *       {isOn ? 'ON' : 'OFF'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useToggle(initialValue?: boolean): [boolean, () => void, (value: boolean) => void];
+/**
+ * Hook to cycle through values
+ * @param values - array of values to cycle through
+ * @param initialIndex - starting index (default: 0)
+ * @returns current value and controls
+ *
+ * @example
+ * ```tsx
+ * function ThemeToggle() {
+ *   const { value, next, prev, setIndex } = useCycle(['light', 'dark', 'system']);
+ *
+ *   return (
+ *     <button onClick={next}>
+ *       Theme: {value}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCycle<T>(values: T[], initialIndex?: number): {
+    value: T;
+    index: number;
+    next: () => void;
+    prev: () => void;
+    setIndex: (index: number) => void;
+    setValue: (value: T) => void;
+};
+/**
+ * Hook for boolean toggle with extended controls
+ * @param initialValue - initial value (default: false)
+ * @returns object with value and control functions
+ *
+ * @example
+ * ```tsx
+ * function Modal() {
+ *   const { value: isOpen, on: open, off: close, toggle } = useBooleanToggle();
+ *
+ *   return (
+ *     <>
+ *       <button onClick={open}>Open</button>
+ *       {isOpen && (
+ *         <div>
+ *           Modal content
+ *           <button onClick={close}>Close</button>
+ *         </div>
+ *       )}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useBooleanToggle(initialValue?: boolean): {
+    value: boolean;
+    toggle: () => void;
+    on: () => void;
+    off: () => void;
+    set: (value: boolean) => void;
+};
+
+interface UseCounterOptions {
+    /** Minimum value (default: -Infinity) */
+    min?: number;
+    /** Maximum value (default: Infinity) */
+    max?: number;
+    /** Step value for increment/decrement (default: 1) */
+    step?: number;
+}
+interface UseCounterReturn {
+    /** Current count value */
+    count: number;
+    /** Increment by step */
+    increment: () => void;
+    /** Decrement by step */
+    decrement: () => void;
+    /** Set to specific value */
+    set: (value: number) => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Whether at minimum value */
+    isMin: boolean;
+    /** Whether at maximum value */
+    isMax: boolean;
+}
+/**
+ * Hook for counter with min/max bounds
+ * @param initialValue - starting value (default: 0)
+ * @param options - configuration options
+ * @returns counter state and controls
+ *
+ * @example
+ * ```tsx
+ * function QuantitySelector() {
+ *   const { count, increment, decrement, isMin, isMax } = useCounter(1, {
+ *     min: 1,
+ *     max: 10,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={decrement} disabled={isMin}>-</button>
+ *       <span>{count}</span>
+ *       <button onClick={increment} disabled={isMax}>+</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useCounter(initialValue?: number, options?: UseCounterOptions): UseCounterReturn;
+/**
+ * Simple increment-only counter
+ * @param initialValue - starting value
+ * @returns count and increment function
+ *
+ * @example
+ * ```tsx
+ * function ClickCounter() {
+ *   const [clicks, addClick] = useIncrementCounter(0);
+ *   return <button onClick={addClick}>Clicks: {clicks}</button>;
+ * }
+ * ```
+ */
+declare function useIncrementCounter(initialValue?: number): [number, () => void];
+
+/**
+ * Hook to get previous value of a variable
+ * @param value - current value
+ * @returns previous value (undefined on first render)
+ *
+ * @example
+ * ```tsx
+ * function Counter() {
+ *   const [count, setCount] = useState(0);
+ *   const previousCount = usePrevious(count);
+ *
+ *   return (
+ *     <div>
+ *       Current: {count}, Previous: {previousCount}
+ *       <button onClick={() => setCount(count + 1)}>+</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePrevious<T>(value: T): T | undefined;
+/**
+ * Hook to get previous value with initial value
+ * @param value - current value
+ * @param initialValue - initial value to return on first render
+ * @returns previous value
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const [value, setValue] = useState(10);
+ *   const previousValue = usePreviousWithInitial(value, 0);
+ *   // First render: previousValue = 0
+ *   // After update: previousValue = previous value
+ * }
+ * ```
+ */
+declare function usePreviousWithInitial<T>(value: T, initialValue: T): T;
+/**
+ * Hook to compare current and previous values
+ * @param value - current value
+ * @returns object with current, previous and hasChanged
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   const [query, setQuery] = useState('');
+ *   const { current, previous, hasChanged } = usePreviousDistinct(query);
+ *
+ *   useEffect(() => {
+ *     if (hasChanged) {
+ *       fetchResults(current);
+ *     }
+ *   }, [current, hasChanged]);
+ * }
+ * ```
+ */
+declare function usePreviousDistinct<T>(value: T): {
+    current: T;
+    previous: T | undefined;
+    hasChanged: boolean;
+};
+
+interface UseListReturn<T> {
+    /** Current list */
+    list: T[];
+    /** Set entire list */
+    set: (newList: T[]) => void;
+    /** Add item to end */
+    push: (item: T) => void;
+    /** Add items to end */
+    pushMany: (items: T[]) => void;
+    /** Add item at index */
+    insertAt: (index: number, item: T) => void;
+    /** Update item at index */
+    updateAt: (index: number, item: T) => void;
+    /** Remove item at index */
+    removeAt: (index: number) => void;
+    /** Remove first occurrence of item */
+    remove: (item: T) => void;
+    /** Remove items matching predicate */
+    removeWhere: (predicate: (item: T) => boolean) => void;
+    /** Remove and return first item */
+    shift: () => T | undefined;
+    /** Add item to beginning */
+    unshift: (item: T) => void;
+    /** Remove and return last item */
+    pop: () => T | undefined;
+    /** Clear all items */
+    clear: () => void;
+    /** Reset to initial list */
+    reset: () => void;
+    /** Move item from one index to another */
+    move: (from: number, to: number) => void;
+    /** Swap two items */
+    swap: (indexA: number, indexB: number) => void;
+    /** Filter list (does not mutate) */
+    filter: (predicate: (item: T) => boolean) => T[];
+    /** Find item */
+    find: (predicate: (item: T) => boolean) => T | undefined;
+    /** Check if list includes item */
+    includes: (item: T) => boolean;
+    /** Get list length */
+    length: number;
+    /** Check if list is empty */
+    isEmpty: boolean;
+}
+/**
+ * Hook for list state management
+ * @param initialList - initial list (default: [])
+ * @returns list state and manipulation functions
+ *
+ * @example
+ * ```tsx
+ * function TodoList() {
+ *   const { list, push, removeAt, updateAt } = useList<string>([
+ *     'Buy groceries',
+ *     'Walk dog',
+ *   ]);
+ *
+ *   return (
+ *     <ul>
+ *       {list.map((item, index) => (
+ *         <li key={index}>
+ *           {item}
+ *           <button onClick={() => removeAt(index)}>Delete</button>
+ *         </li>
+ *       ))}
+ *       <button onClick={() => push('New todo')}>Add</button>
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useList<T>(initialList?: T[]): UseListReturn<T>;
+
+interface UseMapReturn<K, V> {
+    /** Current map as Map object */
+    map: Map<K, V>;
+    /** Get value by key */
+    get: (key: K) => V | undefined;
+    /** Set value for key */
+    set: (key: K, value: V) => void;
+    /** Set multiple entries */
+    setMany: (entries: [K, V][]) => void;
+    /** Check if key exists */
+    has: (key: K) => boolean;
+    /** Delete by key */
+    delete: (key: K) => void;
+    /** Clear all entries */
+    clear: () => void;
+    /** Reset to initial map */
+    reset: () => void;
+    /** Get all keys */
+    keys: () => K[];
+    /** Get all values */
+    values: () => V[];
+    /** Get all entries */
+    entries: () => [K, V][];
+    /** Map size */
+    size: number;
+    /** Whether map is empty */
+    isEmpty: boolean;
+}
+/**
+ * Hook for Map state management
+ * @param initialMap - initial entries (default: [])
+ * @returns map state and manipulation functions
+ *
+ * @example
+ * ```tsx
+ * function UserPreferences() {
+ *   const { map, get, set, delete: remove } = useMap<string, boolean>([
+ *     ['darkMode', true],
+ *     ['notifications', false],
+ *   ]);
+ *
+ *   return (
+ *     <div>
+ *       <label>
+ *         <input
+ *           type="checkbox"
+ *           checked={get('darkMode') ?? false}
+ *           onChange={(e) => set('darkMode', e.target.checked)}
+ *         />
+ *         Dark Mode
+ *       </label>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMap<K, V>(initialEntries?: [K, V][]): UseMapReturn<K, V>;
+/**
+ * Hook for simple object-based key-value store
+ * @param initialObject - initial object
+ * @returns object state and manipulation functions
+ *
+ * @example
+ * ```tsx
+ * function Settings() {
+ *   const { value, get, set, remove } = useRecord<boolean>({
+ *     darkMode: true,
+ *     notifications: false,
+ *   });
+ *
+ *   return <pre>{JSON.stringify(value, null, 2)}</pre>;
+ * }
+ * ```
+ */
+declare function useRecord<T>(initialObject?: Record<string, T>): {
+    value: Record<string, T>;
+    get: (key: string) => T | undefined;
+    set: (key: string, value: T) => void;
+    setAll: (obj: Record<string, T>) => void;
+    remove: (key: string) => void;
+    clear: () => void;
+    reset: () => void;
+    has: (key: string) => boolean;
+    keys: string[];
+    values: T[];
+};
+
+interface UseSetReturn<T> {
+    /** Current set */
+    set: Set<T>;
+    /** Add item to set */
+    add: (item: T) => void;
+    /** Add multiple items */
+    addMany: (items: T[]) => void;
+    /** Remove item from set */
+    remove: (item: T) => void;
+    /** Check if item exists */
+    has: (item: T) => boolean;
+    /** Toggle item (add if not exists, remove if exists) */
+    toggle: (item: T) => void;
+    /** Clear all items */
+    clear: () => void;
+    /** Reset to initial set */
+    reset: () => void;
+    /** Get all values as array */
+    values: () => T[];
+    /** Set size */
+    size: number;
+    /** Whether set is empty */
+    isEmpty: boolean;
+}
+/**
+ * Hook for Set state management
+ * @param initialSet - initial values (default: [])
+ * @returns set state and manipulation functions
+ *
+ * @example
+ * ```tsx
+ * function TagSelector() {
+ *   const { set, add, remove, has, toggle } = useSet<string>(['react']);
+ *
+ *   const tags = ['react', 'vue', 'angular', 'svelte'];
+ *
+ *   return (
+ *     <div>
+ *       {tags.map((tag) => (
+ *         <button
+ *           key={tag}
+ *           onClick={() => toggle(tag)}
+ *           className={has(tag) ? 'selected' : ''}
+ *         >
+ *           {tag}
+ *         </button>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSet<T>(initialValues?: T[]): UseSetReturn<T>;
+/**
+ * Hook for managing selected items (common UI pattern)
+ * @param initialSelection - initial selected items
+ * @returns selection state and controls
+ *
+ * @example
+ * ```tsx
+ * function MultiSelect() {
+ *   const {
+ *     selected,
+ *     isSelected,
+ *     select,
+ *     deselect,
+ *     toggle,
+ *     selectAll,
+ *     deselectAll,
+ *   } = useSelection<string>();
+ *
+ *   const items = ['Item 1', 'Item 2', 'Item 3'];
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => selectAll(items)}>Select All</button>
+ *       <button onClick={deselectAll}>Clear</button>
+ *       {items.map((item) => (
+ *         <label key={item}>
+ *           <input
+ *             type="checkbox"
+ *             checked={isSelected(item)}
+ *             onChange={() => toggle(item)}
+ *           />
+ *           {item}
+ *         </label>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSelection<T>(initialSelection?: T[]): {
+    selected: T[];
+    isSelected: (item: T) => boolean;
+    select: (item: T) => void;
+    deselect: (item: T) => void;
+    toggle: (item: T) => void;
+    selectAll: (items: T[]) => void;
+    deselectAll: () => void;
+    count: number;
+    isEmpty: boolean;
+};
+
+interface UseQueueReturn<T> {
+    /** Current queue */
+    queue: T[];
+    /** Add item to end of queue */
+    enqueue: (item: T) => void;
+    /** Add multiple items to queue */
+    enqueueMany: (items: T[]) => void;
+    /** Remove and return first item */
+    dequeue: () => T | undefined;
+    /** View first item without removing */
+    peek: () => T | undefined;
+    /** View last item */
+    peekLast: () => T | undefined;
+    /** Clear all items */
+    clear: () => void;
+    /** Queue size */
+    size: number;
+    /** Whether queue is empty */
+    isEmpty: boolean;
+    /** Whether queue has items */
+    hasItems: boolean;
+}
+/**
+ * Hook for FIFO queue state management
+ * @param initialQueue - initial queue items
+ * @returns queue state and manipulation functions
+ *
+ * @example
+ * ```tsx
+ * function NotificationQueue() {
+ *   const { queue, enqueue, dequeue, peek, isEmpty } = useQueue<string>();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => enqueue(`Notification ${Date.now()}`)}>
+ *         Add Notification
+ *       </button>
+ *       {!isEmpty && (
+ *         <div>
+ *           <p>Current: {peek()}</p>
+ *           <button onClick={dequeue}>Dismiss</button>
+ *         </div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useQueue<T>(initialQueue?: T[]): UseQueueReturn<T>;
+/**
+ * Hook for LIFO stack state management
+ * @param initialStack - initial stack items
+ * @returns stack state and manipulation functions
+ *
+ * @example
+ * ```tsx
+ * function UndoStack() {
+ *   const { stack, push, pop, peek, isEmpty } = useStack<Action>();
+ *
+ *   const undo = () => {
+ *     const action = pop();
+ *     if (action) revertAction(action);
+ *   };
+ *
+ *   return <button onClick={undo} disabled={isEmpty}>Undo</button>;
+ * }
+ * ```
+ */
+declare function useStack<T>(initialStack?: T[]): {
+    stack: T[];
+    push: (item: T) => void;
+    pushMany: (items: T[]) => void;
+    pop: () => T | undefined;
+    peek: () => T | undefined;
+    clear: () => void;
+    size: number;
+    isEmpty: boolean;
+};
+
+interface AsyncState<T> {
+    /** Resolved data */
+    data: T | null;
+    /** Error if rejected */
+    error: Error | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Whether resolved successfully */
+    isSuccess: boolean;
+    /** Whether rejected with error */
+    isError: boolean;
+    /** Whether idle (not yet executed) */
+    isIdle: boolean;
+}
+interface UseAsyncReturn<T, Args extends unknown[]> extends AsyncState<T> {
+    /** Execute the async function */
+    execute: (...args: Args) => Promise<T | null>;
+    /** Reset to initial state */
+    reset: () => void;
+}
+/**
+ * Hook for managing async function state
+ * @param asyncFunction - async function to manage
+ * @param immediate - whether to execute immediately (default: false)
+ * @returns async state and controls
+ *
+ * @example
+ * ```tsx
+ * function UserProfile({ userId }) {
+ *   const { data, isLoading, error, execute } = useAsync(
+ *     async (id: string) => fetchUser(id),
+ *     false
+ *   );
+ *
+ *   useEffect(() => {
+ *     execute(userId);
+ *   }, [userId, execute]);
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   return <div>{data?.name}</div>;
+ * }
+ * ```
+ */
+declare function useAsync<T, Args extends unknown[] = []>(asyncFunction: (...args: Args) => Promise<T>, immediate?: boolean): UseAsyncReturn<T, Args>;
+/**
+ * Hook for async function with automatic retry
+ * @param asyncFunction - async function
+ * @param retries - number of retries (default: 3)
+ * @param delay - delay between retries in ms (default: 1000)
+ * @returns async state with retry capability
+ *
+ * @example
+ * ```tsx
+ * function DataLoader() {
+ *   const { data, isLoading, execute, retryCount } = useAsyncRetry(
+ *     () => fetchData(),
+ *     3,
+ *     1000
+ *   );
+ *
+ *   return (
+ *     <div>
+ *       {isLoading && `Loading... (attempt ${retryCount + 1})`}
+ *       {data && <DataView data={data} />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAsyncRetry<T, Args extends unknown[] = []>(asyncFunction: (...args: Args) => Promise<T>, retries?: number, delay?: number): UseAsyncReturn<T, Args> & {
+    retryCount: number;
+};
+
+interface FetchState<T> {
+    data: T | null;
+    error: Error | null;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+}
+interface UseFetchOptions<T> {
+    /** Whether to fetch immediately (default: true) */
+    immediate?: boolean;
+    /** Request init options */
+    init?: RequestInit;
+    /** Transform response before setting data */
+    transform?: (data: unknown) => T;
+    /** Dependencies that trigger refetch */
+    deps?: unknown[];
+    /** Whether hook is enabled (default: true) */
+    enabled?: boolean;
+    /** Refetch interval in ms */
+    refetchInterval?: number;
+    /** Cache key for deduplication */
+    cacheKey?: string;
+}
+interface UseFetchReturn<T> extends FetchState<T> {
+    /** Refetch data */
+    refetch: () => Promise<void>;
+    /** Abort current request */
+    abort: () => void;
+}
+/**
+ * Hook for data fetching
+ * @param url - URL to fetch
+ * @param options - fetch options
+ * @returns fetch state and controls
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const { data, isLoading, error, refetch } = useFetch<User[]>(
+ *     '/api/users',
+ *     { immediate: true }
+ *   );
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={refetch}>Refresh</button>
+ *       {data?.map(user => <UserCard key={user.id} user={user} />)}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFetch<T>(url: string | null, options?: UseFetchOptions<T>): UseFetchReturn<T>;
+/**
+ * Hook for POST/PUT/PATCH/DELETE mutations
+ * @param url - URL to mutate
+ * @param options - mutation options
+ * @returns mutation function and state
+ *
+ * @example
+ * ```tsx
+ * function CreateUser() {
+ *   const { mutate, isLoading, error } = useMutation<User>('/api/users', {
+ *     method: 'POST',
+ *   });
+ *
+ *   const handleSubmit = async (data: CreateUserData) => {
+ *     const result = await mutate(data);
+ *     if (result) {
+ *       // Success
+ *     }
+ *   };
+ *
+ *   return <form onSubmit={handleSubmit}>...</form>;
+ * }
+ * ```
+ */
+declare function useMutation<T, Body = unknown>(url: string, options?: Omit<RequestInit, "body"> & {
+    transform?: (data: unknown) => T;
+}): FetchState<T> & {
+    mutate: (body?: Body) => Promise<T | null>;
+    reset: () => void;
+};
+
+/**
+ * Hook to run callback at interval
+ * @param callback - function to run
+ * @param delay - interval in ms (null to pause)
+ *
+ * @example
+ * ```tsx
+ * function Timer() {
+ *   const [seconds, setSeconds] = useState(0);
+ *
+ *   useInterval(() => {
+ *     setSeconds(s => s + 1);
+ *   }, 1000);
+ *
+ *   return <div>Elapsed: {seconds}s</div>;
+ * }
+ * ```
+ */
+declare function useInterval(callback: () => void, delay: number | null): void;
+/**
+ * Hook to run interval with controls
+ * @param callback - function to run
+ * @param delay - interval in ms
+ * @returns interval controls
+ *
+ * @example
+ * ```tsx
+ * function StopWatch() {
+ *   const [time, setTime] = useState(0);
+ *   const { start, stop, isRunning, toggle } = useIntervalControls(
+ *     () => setTime(t => t + 100),
+ *     100
+ *   );
+ *
+ *   return (
+ *     <div>
+ *       <span>{time}ms</span>
+ *       <button onClick={toggle}>{isRunning ? 'Pause' : 'Start'}</button>
+ *       <button onClick={() => { stop(); setTime(0); }}>Reset</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useIntervalControls(callback: () => void, delay: number): {
+    start: () => void;
+    stop: () => void;
+    toggle: () => void;
+    isRunning: boolean;
+};
+/**
+ * Hook for countdown timer
+ * @param initialSeconds - starting seconds
+ * @param options - configuration options
+ * @returns countdown state and controls
+ *
+ * @example
+ * ```tsx
+ * function Countdown() {
+ *   const {
+ *     seconds,
+ *     isRunning,
+ *     isComplete,
+ *     start,
+ *     pause,
+ *     reset,
+ *   } = useCountdown(60);
+ *
+ *   return (
+ *     <div>
+ *       <span>{seconds}s</span>
+ *       {!isRunning && !isComplete && <button onClick={start}>Start</button>}
+ *       {isRunning && <button onClick={pause}>Pause</button>}
+ *       <button onClick={() => reset(60)}>Reset</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useCountdown(initialSeconds: number, options?: {
+    interval?: number;
+    onComplete?: () => void;
+    autoStart?: boolean;
+}): {
+    seconds: number;
+    isRunning: boolean;
+    isComplete: boolean;
+    start: () => void;
+    pause: () => void;
+    reset: (newSeconds?: number) => void;
+};
+/**
+ * Hook for count-up timer
+ * @param options - configuration options
+ * @returns timer state and controls
+ *
+ * @example
+ * ```tsx
+ * function Timer() {
+ *   const { seconds, start, stop, reset } = useTimer();
+ *
+ *   return (
+ *     <div>
+ *       {Math.floor(seconds / 60)}:{String(seconds % 60).padStart(2, '0')}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useTimer(options?: {
+    interval?: number;
+    maxSeconds?: number;
+    autoStart?: boolean;
+}): {
+    seconds: number;
+    isRunning: boolean;
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+    toggle: () => void;
+};
+
+/**
+ * Hook to run callback after delay
+ * @param callback - function to run
+ * @param delay - delay in ms (null to not run)
+ *
+ * @example
+ * ```tsx
+ * function Notification() {
+ *   const [visible, setVisible] = useState(true);
+ *
+ *   useTimeout(() => {
+ *     setVisible(false);
+ *   }, 5000);
+ *
+ *   return visible ? <div>Notification</div> : null;
+ * }
+ * ```
+ */
+declare function useTimeout(callback: () => void, delay: number | null): void;
+/**
+ * Hook to run timeout with controls
+ * @param callback - function to run
+ * @param delay - delay in ms
+ * @returns timeout controls
+ *
+ * @example
+ * ```tsx
+ * function AutoSave() {
+ *   const { start, cancel, isScheduled } = useTimeoutControls(
+ *     () => saveData(),
+ *     3000
+ *   );
+ *
+ *   const handleChange = () => {
+ *     cancel(); // Cancel previous
+ *     start();  // Schedule new
+ *   };
+ *
+ *   return <input onChange={handleChange} />;
+ * }
+ * ```
+ */
+declare function useTimeoutControls(callback: () => void, delay: number): {
+    start: () => void;
+    cancel: () => void;
+    reset: () => void;
+    isScheduled: boolean;
+};
+/**
+ * Hook for delayed state updates
+ * @param value - value to delay
+ * @param delay - delay in ms
+ * @returns delayed value
+ *
+ * @example
+ * ```tsx
+ * function SearchInput() {
+ *   const [query, setQuery] = useState('');
+ *   const delayedQuery = useDelayedValue(query, 500);
+ *
+ *   useEffect(() => {
+ *     // Only search after user stops typing
+ *     if (delayedQuery) {
+ *       searchApi(delayedQuery);
+ *     }
+ *   }, [delayedQuery]);
+ *
+ *   return <input value={query} onChange={e => setQuery(e.target.value)} />;
+ * }
+ * ```
+ */
+declare function useDelayedValue<T>(value: T, delay: number): T;
+/**
+ * Hook that returns true after delay
+ * @param delay - delay in ms
+ * @param immediate - whether to start immediately (default: true)
+ * @returns whether delay has passed
+ *
+ * @example
+ * ```tsx
+ * function LazyLoad() {
+ *   const ready = useTimeoutFlag(1000);
+ *
+ *   return ready ? <HeavyComponent /> : <Skeleton />;
+ * }
+ * ```
+ */
+declare function useTimeoutFlag(delay: number, immediate?: boolean): boolean;
+
+interface RafLoopReturn {
+    /** Start the animation loop */
+    start: () => void;
+    /** Stop the animation loop */
+    stop: () => void;
+    /** Whether loop is running */
+    isRunning: boolean;
+    /** Current frame count */
+    frameCount: number;
+    /** FPS (frames per second) */
+    fps: number;
+}
+/**
+ * Hook to run callback on each animation frame
+ * @param callback - function called each frame with delta time
+ * @param autoStart - whether to start immediately (default: true)
+ * @returns loop controls
+ *
+ * @example
+ * ```tsx
+ * function Animation() {
+ *   const { start, stop, isRunning, fps } = useRafLoop((deltaTime) => {
+ *     // Update animation based on deltaTime
+ *     positionRef.current += velocity * deltaTime;
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <span>FPS: {fps.toFixed(0)}</span>
+ *       <button onClick={isRunning ? stop : start}>
+ *         {isRunning ? 'Pause' : 'Play'}
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useRafLoop(callback: (deltaTime: number, timestamp: number) => void, autoStart?: boolean): RafLoopReturn;
+/**
+ * Hook for smooth value animation using RAF
+ * @param targetValue - value to animate to
+ * @param options - animation options
+ * @returns current animated value
+ *
+ * @example
+ * ```tsx
+ * function ProgressBar() {
+ *   const [progress, setProgress] = useState(0);
+ *   const animatedProgress = useAnimatedValue(progress, {
+ *     duration: 500,
+ *     easing: 'easeOutCubic',
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <div style={{ width: `${animatedProgress}%` }} />
+ *       <button onClick={() => setProgress(p => p + 25)}>+25%</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAnimatedValue(targetValue: number, options?: {
+    duration?: number;
+    easing?: "linear" | "easeInCubic" | "easeOutCubic" | "easeInOutCubic";
+}): number;
+/**
+ * Hook for spring-like animations
+ * @param targetValue - value to animate to
+ * @param config - spring configuration
+ * @returns current animated value
+ *
+ * @example
+ * ```tsx
+ * function SpringBox() {
+ *   const [target, setTarget] = useState(0);
+ *   const x = useSpringValue(target, { stiffness: 200, damping: 20 });
+ *
+ *   return (
+ *     <div style={{ transform: `translateX(${x}px)` }}>
+ *       <button onClick={() => setTarget(t => t + 50)}>Move</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSpringValue(targetValue: number, config?: {
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+}): number;
+
+interface UseIdleOptions {
+    /** Events that reset the idle timer */
+    events?: (keyof WindowEventMap)[];
+    /** Initial idle state (default: false) */
+    initialState?: boolean;
+    /** Whether the hook is enabled (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Hook to detect user idle state
+ * @param timeout - idle timeout in milliseconds
+ * @param options - configuration options
+ * @returns whether the user is idle
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const isIdle = useIdle(60000); // 1 minute
+ *
+ *   if (isIdle) {
+ *     return <SessionTimeoutWarning />;
+ *   }
+ *
+ *   return <MainContent />;
+ * }
+ * ```
+ */
+declare function useIdle(timeout: number, options?: UseIdleOptions): boolean;
+/**
+ * Hook to detect user idle state with callbacks
+ * @param timeout - idle timeout in milliseconds
+ * @param onIdle - callback when user becomes idle
+ * @param onActive - callback when user becomes active
+ * @param options - configuration options
+ * @returns whether the user is idle
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const isIdle = useIdleCallback(
+ *     60000,
+ *     () => pauseVideo(),
+ *     () => resumeVideo()
+ *   );
+ * }
+ * ```
+ */
+declare function useIdleCallback(timeout: number, onIdle?: () => void, onActive?: () => void, options?: UseIdleOptions): boolean;
+
+type VisibilityState = "visible" | "hidden" | "prerender";
+/**
+ * Hook to detect document visibility state
+ * @returns current visibility state
+ *
+ * @example
+ * ```tsx
+ * function VideoPlayer() {
+ *   const visibility = useDocumentVisibility();
+ *
+ *   useEffect(() => {
+ *     if (visibility === 'hidden') {
+ *       pauseVideo();
+ *     }
+ *   }, [visibility]);
+ *
+ *   return <video />;
+ * }
+ * ```
+ */
+declare function useDocumentVisibility(): VisibilityState;
+/**
+ * Hook to detect if document is visible
+ * @returns whether document is visible
+ *
+ * @example
+ * ```tsx
+ * function Timer() {
+ *   const isVisible = useDocumentIsVisible();
+ *
+ *   // Pause timer when tab is not visible
+ *   useEffect(() => {
+ *     if (!isVisible) return;
+ *     const interval = setInterval(() => tick(), 1000);
+ *     return () => clearInterval(interval);
+ *   }, [isVisible]);
+ * }
+ * ```
+ */
+declare function useDocumentIsVisible(): boolean;
+/**
+ * Hook to run callback when visibility changes
+ * @param onVisible - callback when document becomes visible
+ * @param onHidden - callback when document becomes hidden
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   useDocumentVisibilityCallback(
+ *     () => refetchData(),
+ *     () => saveState()
+ *   );
+ * }
+ * ```
+ */
+declare function useDocumentVisibilityCallback(onVisible?: () => void, onHidden?: () => void): void;
+
+/**
+ * Hook to detect online/offline status
+ * @returns whether the browser is online
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const isOnline = useOnlineStatus();
+ *
+ *   if (!isOnline) {
+ *     return <OfflineWarning />;
+ *   }
+ *
+ *   return <MainApp />;
+ * }
+ * ```
+ */
+declare function useOnlineStatus(): boolean;
+/**
+ * Hook to run callbacks on online/offline status change
+ * @param onOnline - callback when going online
+ * @param onOffline - callback when going offline
+ * @returns whether the browser is online
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const isOnline = useOnlineStatusCallback(
+ *     () => syncData(),
+ *     () => showOfflineToast()
+ *   );
+ * }
+ * ```
+ */
+declare function useOnlineStatusCallback(onOnline?: () => void, onOffline?: () => void): boolean;
+
+interface UseFullscreenReturn {
+    /** Whether currently in fullscreen */
+    isFullscreen: boolean;
+    /** Enter fullscreen */
+    enter: () => Promise<void>;
+    /** Exit fullscreen */
+    exit: () => Promise<void>;
+    /** Toggle fullscreen */
+    toggle: () => Promise<void>;
+    /** Whether fullscreen is supported */
+    isSupported: boolean;
+}
+/**
+ * Hook for fullscreen API
+ * @param ref - element to make fullscreen (default: document)
+ * @returns fullscreen state and controls
+ *
+ * @example
+ * ```tsx
+ * function VideoPlayer() {
+ *   const videoRef = useRef<HTMLVideoElement>(null);
+ *   const { isFullscreen, toggle, isSupported } = useFullscreen(videoRef);
+ *
+ *   return (
+ *     <div>
+ *       <video ref={videoRef} src="/video.mp4" />
+ *       {isSupported && (
+ *         <button onClick={toggle}>
+ *           {isFullscreen ? 'Exit' : 'Enter'} Fullscreen
+ *         </button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFullscreen<T extends HTMLElement = HTMLElement>(ref?: RefObject<T | null>): UseFullscreenReturn;
+/**
+ * Hook for fullscreen with automatic element ref
+ * @returns ref to attach and fullscreen controls
+ *
+ * @example
+ * ```tsx
+ * function Gallery() {
+ *   const { ref, isFullscreen, toggle } = useFullscreenRef<HTMLDivElement>();
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <img src="/photo.jpg" />
+ *       <button onClick={toggle}>Fullscreen</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFullscreenRef<T extends HTMLElement = HTMLElement>(): UseFullscreenReturn & {
+    ref: RefObject<T | null>;
+};
+
+interface GeolocationState {
+    /** Whether currently loading */
+    isLoading: boolean;
+    /** Current position */
+    position: GeolocationPosition | null;
+    /** Error if failed */
+    error: GeolocationPositionError | null;
+    /** Latitude */
+    latitude: number | null;
+    /** Longitude */
+    longitude: number | null;
+    /** Accuracy in meters */
+    accuracy: number | null;
+    /** Altitude in meters */
+    altitude: number | null;
+    /** Altitude accuracy in meters */
+    altitudeAccuracy: number | null;
+    /** Heading in degrees */
+    heading: number | null;
+    /** Speed in m/s */
+    speed: number | null;
+    /** Timestamp of position */
+    timestamp: number | null;
+}
+interface UseGeolocationOptions extends PositionOptions {
+    /** Whether to watch position continuously (default: false) */
+    watch?: boolean;
+    /** Whether to get position immediately (default: true) */
+    immediate?: boolean;
+}
+interface UseGeolocationReturn extends GeolocationState {
+    /** Manually get current position */
+    getCurrentPosition: () => void;
+    /** Whether geolocation is supported */
+    isSupported: boolean;
+}
+/**
+ * Hook for Geolocation API
+ * @param options - geolocation options
+ * @returns geolocation state and controls
+ *
+ * @example
+ * ```tsx
+ * function LocationDisplay() {
+ *   const {
+ *     latitude,
+ *     longitude,
+ *     isLoading,
+ *     error,
+ *     getCurrentPosition,
+ *   } = useGeolocation({ immediate: false });
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <div>
+ *       {latitude && longitude ? (
+ *         <p>Lat: {latitude}, Lng: {longitude}</p>
+ *       ) : (
+ *         <button onClick={getCurrentPosition}>Get Location</button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationReturn;
+/**
+ * Hook to calculate distance between two coordinates
+ * @param lat1 - latitude of first point
+ * @param lon1 - longitude of first point
+ * @param lat2 - latitude of second point
+ * @param lon2 - longitude of second point
+ * @returns distance in meters
+ *
+ * @example
+ * ```tsx
+ * function DistanceCalculator() {
+ *   const { latitude, longitude } = useGeolocation();
+ *   const targetLat = 40.7128;
+ *   const targetLon = -74.0060;
+ *
+ *   const distance = useDistance(latitude, longitude, targetLat, targetLon);
+ *
+ *   return <p>Distance to NYC: {(distance / 1000).toFixed(1)} km</p>;
+ * }
+ * ```
+ */
+declare function useDistance(lat1: number | null, lon1: number | null, lat2: number | null, lon2: number | null): number | null;
+
+type PermissionNameType = "geolocation" | "notifications" | "push" | "midi" | "camera" | "microphone" | "speaker" | "device-info" | "background-fetch" | "background-sync" | "bluetooth" | "persistent-storage" | "ambient-light-sensor" | "accelerometer" | "gyroscope" | "magnetometer" | "clipboard-read" | "clipboard-write" | "display-capture" | "nfc";
+interface UsePermissionReturn {
+    /** Current permission state */
+    state: PermissionState | null;
+    /** Whether permission is granted */
+    isGranted: boolean;
+    /** Whether permission is denied */
+    isDenied: boolean;
+    /** Whether permission requires prompt */
+    isPrompt: boolean;
+    /** Whether loading */
+    isLoading: boolean;
+    /** Whether supported */
+    isSupported: boolean;
+    /** Query permission status */
+    query: () => Promise<PermissionState | null>;
+}
+/**
+ * Hook for Permissions API
+ * @param permissionName - name of permission to check
+ * @returns permission state and controls
+ *
+ * @example
+ * ```tsx
+ * function NotificationButton() {
+ *   const { state, isGranted, isDenied, isPrompt } = usePermission('notifications');
+ *
+ *   if (isDenied) {
+ *     return <p>Notifications are blocked. Please enable in settings.</p>;
+ *   }
+ *
+ *   if (isPrompt) {
+ *     return (
+ *       <button onClick={() => Notification.requestPermission()}>
+ *         Enable Notifications
+ *       </button>
+ *     );
+ *   }
+ *
+ *   if (isGranted) {
+ *     return <p>Notifications are enabled!</p>;
+ *   }
+ *
+ *   return null;
+ * }
+ * ```
+ */
+declare function usePermission(permissionName: PermissionNameType): UsePermissionReturn;
+/**
+ * Hook to request notification permission
+ * @returns permission state and request function
+ *
+ * @example
+ * ```tsx
+ * function NotificationSetup() {
+ *   const { permission, request, isSupported } = useNotificationPermission();
+ *
+ *   if (!isSupported) {
+ *     return <p>Notifications not supported</p>;
+ *   }
+ *
+ *   return (
+ *     <button onClick={request} disabled={permission !== 'default'}>
+ *       {permission === 'granted' ? 'Enabled' : 'Enable Notifications'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useNotificationPermission(): {
+    permission: NotificationPermission;
+    request: () => Promise<NotificationPermission>;
+    isSupported: boolean;
+};
+/**
+ * Hook to request camera/microphone permission
+ * @param constraints - MediaStreamConstraints
+ * @returns stream state and request function
+ *
+ * @example
+ * ```tsx
+ * function VideoChat() {
+ *   const { stream, error, request, stop } = useMediaPermission({
+ *     video: true,
+ *     audio: true,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {error && <p>Permission denied: {error.message}</p>}
+ *       {!stream && <button onClick={request}>Start Camera</button>}
+ *       {stream && (
+ *         <>
+ *           <video autoPlay ref={(el) => el && (el.srcObject = stream)} />
+ *           <button onClick={stop}>Stop</button>
+ *         </>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMediaPermission(constraints: MediaStreamConstraints): {
+    stream: MediaStream | null;
+    error: Error | null;
+    isLoading: boolean;
+    request: () => Promise<MediaStream | null>;
+    stop: () => void;
+    isSupported: boolean;
+};
+
+declare global {
+    interface Window {
+        SpeechRecognition?: any;
+        webkitSpeechRecognition?: any;
+    }
+}
+interface UseSpeechSynthesisOptions {
+    /** Voice to use */
+    voice?: SpeechSynthesisVoice | null;
+    /** Speech rate (0.1 - 10) */
+    rate?: number;
+    /** Speech pitch (0 - 2) */
+    pitch?: number;
+    /** Speech volume (0 - 1) */
+    volume?: number;
+    /** Language code */
+    lang?: string;
+}
+interface UseSpeechSynthesisReturn {
+    /** Speak text */
+    speak: (text: string) => void;
+    /** Stop speaking */
+    stop: () => void;
+    /** Pause speaking */
+    pause: () => void;
+    /** Resume speaking */
+    resume: () => void;
+    /** Whether currently speaking */
+    isSpeaking: boolean;
+    /** Whether paused */
+    isPaused: boolean;
+    /** Whether supported */
+    isSupported: boolean;
+    /** Available voices */
+    voices: SpeechSynthesisVoice[];
+}
+/**
+ * Hook for Speech Synthesis (Text-to-Speech)
+ * @param options - speech options
+ * @returns speech controls and state
+ *
+ * @example
+ * ```tsx
+ * function TextReader() {
+ *   const { speak, stop, isSpeaking, voices } = useSpeechSynthesis({
+ *     rate: 1,
+ *     pitch: 1,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <select onChange={(e) => setVoice(voices.find(v => v.name === e.target.value))}>
+ *         {voices.map((voice) => (
+ *           <option key={voice.name} value={voice.name}>{voice.name}</option>
+ *         ))}
+ *       </select>
+ *       <button onClick={() => speak("Hello, world!")}>
+ *         {isSpeaking ? 'Speaking...' : 'Speak'}
+ *       </button>
+ *       {isSpeaking && <button onClick={stop}>Stop</button>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSpeechSynthesis(options?: UseSpeechSynthesisOptions): UseSpeechSynthesisReturn;
+interface UseSpeechRecognitionOptions {
+    /** Language code (default: 'en-US') */
+    lang?: string;
+    /** Continuous listening (default: false) */
+    continuous?: boolean;
+    /** Interim results (default: true) */
+    interimResults?: boolean;
+}
+interface UseSpeechRecognitionReturn {
+    /** Start listening */
+    start: () => void;
+    /** Stop listening */
+    stop: () => void;
+    /** Abort listening */
+    abort: () => void;
+    /** Whether currently listening */
+    isListening: boolean;
+    /** Recognized transcript */
+    transcript: string;
+    /** Interim transcript */
+    interimTranscript: string;
+    /** Whether supported */
+    isSupported: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Reset transcript */
+    reset: () => void;
+}
+/**
+ * Hook for Speech Recognition (Speech-to-Text)
+ * @param options - recognition options
+ * @returns recognition controls and state
+ *
+ * @example
+ * ```tsx
+ * function VoiceInput() {
+ *   const {
+ *     transcript,
+ *     isListening,
+ *     start,
+ *     stop,
+ *     reset,
+ *     isSupported,
+ *   } = useSpeechRecognition({ lang: 'en-US' });
+ *
+ *   if (!isSupported) {
+ *     return <p>Speech recognition not supported</p>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>{transcript || 'Start speaking...'}</p>
+ *       <button onClick={isListening ? stop : start}>
+ *         {isListening ? '🔴 Stop' : '🎤 Start'}
+ *       </button>
+ *       <button onClick={reset}>Clear</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSpeechRecognition(options?: UseSpeechRecognitionOptions): UseSpeechRecognitionReturn;
+
 /**
  * Combines class names with Tailwind CSS class merging
  * @example cn("px-2 py-1", "px-4") => "py-1 px-4"
  */
 declare function cn(...inputs: ClassValue[]): string;
 
-export { Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, ActionBar, ActionBarButton, type ActionBarProps, ActionGroup, type ActionGroupItem, type ActionGroupProps, ActionIcon, type ActionIconProps, ActionMenu, type ActionMenuGroup, type ActionMenuItem, type ActionMenuProps, ActionSheet, type ActionSheetItem, type ActionSheetProps, Alert, AlertDescription, type AlertRadius, AlertTitle, type AlertType, type AlertVariant, type AllowDropInfo, AppShell, AppShellAside, AppShellFooter, AppShellHeader, AppShellMain, type AppShellProps, AppShellSidebar, AreaChart, type AreaChartProps, AspectRatio, AuthDivider, AuthFooterLinks, AuthForm, AuthHeader, AuthLayout, type AuthLayoutProps, AuthSocialButtons, Autocomplete, type AutocompleteOption, type AutocompleteProps, Avatar, AvatarFallback, AvatarGroup, type AvatarGroupItem, type AvatarGroupProps, AvatarImage, BackTop, type BackTopProps, Badge, type BadgeProps, Banner, type BannerProps, BarChart, type BarChartProps, BatteryMeter, Blockquote, type BlockquoteProps, BottomNavigation, type BottomNavigationItem, type BottomNavigationProps, Bounce, type BounceProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, COUNTRIES, Calendar, type CalendarEvent, type CalendarProps, type CalendarView, Card, CardContent, CardFooter, CardHeader, Carousel, type CarouselApi, CarouselContent, CarouselItem, type CarouselItemProps, CarouselNext, CarouselPrevious, type CarouselProps, Center, type ChartDataPoint, type CheckInfo, Checkbox, Checkmark, type CheckmarkProps, type CheckmarkSize, type CheckmarkVariant, Chip, type ChipProps, CircularProgress, CloseButton, type CloseButtonProps, Code, Collapse, type CollapseProps, Collapsible, CollapsibleContent, CollapsibleTrigger, ColorArea, type ColorAreaProps, type ColorAreaValue, ColorField, type ColorFieldProps, ColorPicker, type ColorPickerProps, ColorSlider, type ColorSliderChannel, type ColorSliderProps, ColorSwatch, ColorSwatchPicker, type ColorSwatchPickerProps, type ColorSwatchProps, ColorWheel, type ColorWheelProps, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, Confetti, type ConfettiOptions, type ConfettiProps, ConfirmDialog, type ConfirmDialogProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, ContextualHelp, type ContextualHelpProps, CopyButton, type CopyButtonProps, Counter, type CounterProps, type Country, CurrencyInput, type CurrencyInputProps, DEFAULT_COLORS, DashboardGrid, DashboardLayout, type DashboardLayoutProps, DashboardPage, DashboardPageHeader, DataTable, type DataTableProps, DateField, type DateFieldProps, type DateFormat, DateInput, type DateInputProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, DefaultErrorFallback, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiskUsageMeter, Dots, type DragInfo, type DraggableConfig, Drawer, type DrawerBackdrop, DrawerBody, DrawerClose, type DrawerCollapsible, DrawerContent, DrawerDescription, DrawerFooter, DrawerGroup, DrawerGroupLabel, DrawerHeader, DrawerInset, DrawerMenu, DrawerMenuButton, DrawerMenuItem, type DrawerMode, type DrawerPlacement, type DrawerProps, DrawerProvider, DrawerSeparator, DrawerSidebar, type DrawerSidebarProps, type DrawerSize, DrawerTitle, DrawerToggle, DrawerTrigger, type DrawerVariant, type DropInfo, Dropdown, DropdownCheckboxItem, type DropdownCheckboxItemProps, DropdownContent, type DropdownContentProps, DropdownGroup, type DropdownGroupProps, DropdownItem, type DropdownItemProps, DropdownLabel, type DropdownLabelProps, type DropdownProps, DropdownRadioGroup, type DropdownRadioGroupProps, DropdownRadioItem, type DropdownRadioItemProps, DropdownSeparator, type DropdownSeparatorProps, DropdownShortcut, DropdownSub, DropdownSubContent, type DropdownSubContentProps, type DropdownSubProps, DropdownSubTrigger, type DropdownSubTriggerProps, DropdownTrigger, type DropdownTriggerProps, EMOJIS, EMOJI_CATEGORIES, EmojiPicker, type EmojiPickerProps, EmptyState, ErrorBoundary, type ErrorBoundaryProps, Expand, type ExpandInfo, type ExpandProps, FAB, type FABAction, Fade, type FadeProps, FieldContext, type FieldContextValue, type FieldState, type FileRejection, FileUpload, type FileUploadProps, type FlatCheckInfo, type FlatSelectInfo, Flex, type FlexProps, Flip, type FlipDirection, type FlipProps, FloatingActionButton, type FloatingActionButtonProps, Form, FormContext, type FormContextValue, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, type FormFieldProps, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, type FormProps, type FormState, FullCalendar, type FullCalendarProps, Glow, type GlowProps, Grid, GridItem, type GridItemProps, GridList, type GridListItem, type GridListProps, type GridProps, H1, type H1Props, H2, type H2Props, H3, type H3Props, H4, type H4Props, HStack, HoverCard, HoverCardContent, HoverCardTrigger, IconButton, type IconButtonProps, IllustratedMessage, type IllustratedMessageProps, Image, ImageCropper, type ImageCropperProps, ImageViewer, type ImageViewerProps, ImageViewerTrigger, type ImageViewerTriggerProps, Indicator, type IndicatorProps, IndicatorWrapper, type IndicatorWrapperProps, InfiniteScroll, type InfiniteScrollProps, InlineAlert, type InlineAlertProps, InlineCode, type InlineCodeProps, Input, InputOTP, InputOTPGroup, type InputOTPProps, InputOTPSeparator, InputOTPSlot, type InputOTPSlotProps, type InputProps, KanbanBoard, type KanbanBoardProps, type KanbanCard, type KanbanColumn, Kbd, type KbdProps, Label, LabeledValue, LabeledValueGroup, type LabeledValueGroupProps, type LabeledValueProps, Large, type LargeProps, Lead, type LeadProps, LineChart, type LineChartProps, Link, type LinkProps, List, type ListDataItem, ListItemComponent as ListItem, type ListItemComponentProps, ListItemText, type ListItemTextProps, type ListProps, ListView, type ListViewItem, type ListViewProps, Listbox, ListboxItem, type ListboxOption, Loading, LoadingOverlay, type LoadingOverlayProps, type LoadingProps, MASK_PRESETS, type MaskChar, type MaskDefinition, type MaskPreset, MaskedInput, type MaskedInputProps, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, Meter, type MeterProps, Modal, type ModalBackdrop, ModalBody, ModalClose, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalOverlay, type ModalPlacement, ModalPortal, type ModalProps, ModalRoot, type ModalScrollBehavior, ModalTitle, ModalTrigger, Muted, type MutedProps, NProgress, type NProgressProps, Navbar, NavbarBrand, NavbarContent, NavbarItem, NavbarLink, type NavbarProps, NavigationMenu, NavigationMenuContent, type NavigationMenuContentProps, NavigationMenuIndicator, type NavigationMenuIndicatorProps, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, type NavigationMenuLinkProps, NavigationMenuList, type NavigationMenuListProps, type NavigationMenuProps, NavigationMenuTrigger, type NavigationMenuTriggerProps, NavigationMenuViewport, type Notification, NotificationCenter, NotificationCenterContent, type NotificationCenterContentProps, type NotificationCenterProps, NotificationCenterProvider, type NotificationCenterProviderProps, NotificationCenterTrigger, type NotificationCenterTriggerProps, NotificationItem, type NotificationItemProps, NotificationList, type NotificationListProps, NumberField, type NumberFieldProps, NumberInput, type NumberInputProps, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, type PaginationState, Paragraph, type ParagraphProps, Parallax, type ParallaxProps, PasswordInput, type PasswordInputProps, PhoneInput, type PhoneInputProps, PieChart, type PieChartProps, Pop, type PopProps, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, Portal, type PortalProps, Progress, PullToRefresh, type PullToRefreshProps, Pulse, type PulseProps, type PulseSpeed, QRCode, type QRCodeProps, RadioGroup, RadioGroupItem, RangeSlider, type RangeSliderProps, Rating, type RatingProps, ResizableHandle, type ResizableHandleProps, ResizablePanel, ResizablePanelGroup, type ResizablePanelGroupProps, RichTextEditor, type RichTextEditorProps, Ripple, type RippleProps, Rotate, type RotateProps, Scale, type ScaleOrigin, type ScaleProps, ScrollArea, type ScrollAreaProps, ScrollProgress, type ScrollProgressPosition, type ScrollProgressProps, ScrollReveal, type ScrollRevealDirection, type ScrollRevealProps, ScrollShadow, type ScrollShadowProps, SearchBar, type SearchBarProps, SearchField, type SearchFieldProps, type SearchSuggestion, SegmentedControl, SegmentedControlItem, type SegmentedControlItemProps, type SegmentedControlProps, Select, type SelectInfo, type SelectOption, type SelectProps, Separator, type SeparatorProps, SettingsCard, SettingsHeader, SettingsLayout, type SettingsLayoutProps, SettingsNavItem, SettingsRow, SettingsSection, SettingsSeparator, Shake, type ShakeIntensity, type ShakeProps, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Shimmer, type ShimmerDirection, type ShimmerProps, SimpleGrid, Skeleton, Slide, type SlideDirection, type SlideProps, Slider, Small, type SmallProps, Snippet, type SortDirection, type SortState, type SortableItem, SortableList, Spacer, type SpacerProps, Sparkles, type SparklesProps, Spinner, type SpotlightItem, SpotlightSearch, type SpotlightSearchProps, StatCard, StatusLight, type StatusLightProps, Step, type StepProps, Steps, type StepsProps, type SwipeAction, SwipeActions, type SwipeActionsProps, Switch, type SwitchColor, type SwitchProps, type SwitchSize, Table, TableBody, TableCaption, TableCell, type TableColumn, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, type Tag, TagGroup, type TagGroupProps, TagInput, type TagInputProps, type TagItem, TextBadge, type TextBadgeProps, TextField, type TextFieldProps, TextReveal, type TextRevealDirection, type TextRevealProps, Textarea, type TextareaProps, ThemeProvider, type ThemeProviderProps, ThemeToggle, type ThemeToggleProps, TimeField, type TimeFieldProps, TimeInput, type TimeInputProps, TimePicker, type TimePickerProps, type TimeValue, Timeline, TimelineContent, TimelineItem, TimelineOpposite, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TransitionProps, Tree, type TreeNode, type TreeProps, Typewriter, type TypewriterProps, UL, type ULProps, type UploadedFile, User, VStack, type ValidationRule, type ViewerImage, VirtualList, type VirtualListProps, VisuallyHidden, type VisuallyHiddenProps, Well, type WellProps, Wiggle, type WiggleProps, WordRotate, type WordRotateProps, actionBarVariants, actionGroupVariants, actionIconVariants, actionMenuTriggerVariants, actionSheetItemVariants, alertVariants, appShellVariants, applyMask, authLayoutVariants, autocompleteInputVariants, avatarGroupVariants, backTopVariants, badgeIndicatorVariants, bannerVariants, bottomNavigationVariants, buttonGroupVariants, buttonVariants, cardVariants, carouselVariants, chartContainerVariants, chipVariants, circularProgressVariants, closeButtonVariants, cn, codeVariants, colorAreaVariants, colorFieldVariants, colorSliderVariants, colorSwatchPickerVariants, colorSwatchVariants, colorWheelVariants, confirmDialogIconVariants, contextualHelpTriggerVariants, copyButtonVariants, currencyInputVariants, dashboardLayoutVariants, dateFieldVariants, dateInputVariants, dotsVariants, drawerMenuButtonVariants, emojiPickerVariants, emptyStateVariants, fabVariants, fileUploadVariants, flexVariants, formatCurrency, formatDate, formatFileSize, formatPhoneNumber, fullCalendarVariants, getFileIcon, getMaskPlaceholder, gridItemVariants, gridListItemVariants, gridListVariants, gridVariants, hexToRgb, hsvToRgb, iconButtonVariants, illustratedMessageVariants, imageCropperVariants, imageVariants, indicatorVariants, infiniteScrollLoaderVariants, infiniteScrollVariants, inlineAlertVariants, inputOTPVariants, inputSizeVariants, kanbanBoardVariants, kanbanCardVariants, kanbanColumnVariants, kbdVariants, labelSizeVariants, labeledValueGroupVariants, labeledValueVariants, linkVariants, listItemVariants, listVariants, listViewItemVariants, listViewVariants, listboxItemVariants, listboxVariants, loadingOverlayVariants, loadingVariants, maskedInputVariants, meterVariants, modalContentVariants, navbarVariants, navigationMenuLinkStyle, navigationMenuTriggerStyle, nprogressVariants, numberFieldVariants, parseDate, parseFormattedValue, phoneInputVariants, pullToRefreshVariants, qrCodeVariants, rangeSliderVariants, ratingVariants, rgbToHex, rgbToHsv, richTextEditorVariants, scrollShadowVariants, searchBarVariants, searchFieldVariants, segmentedControlItemVariants, segmentedControlVariants, selectVariants, settingsLayoutVariants, sheetVariants, skeletonVariants, snippetVariants, sortableItemVariants, sortableListVariants, spinnerVariants, statCardVariants, statusLightVariants, stepVariants, stepsVariants, swipeActionVariants, swipeActionsVariants, colorMap as switchColors, tagGroupItemVariants, tagGroupVariants, tagVariants, textBadgeVariants, textFieldVariants, themeToggleVariants, timeFieldVariants, timeInputVariants, timelineItemVariants, timelineVariants, toggleVariants, treeItemVariants, treeVariants, unmask, useButtonGroup, useCarousel, useConfetti, useConfirmDialog, useDrawer, useFieldContext, useFormContext, useKeyboardShortcut, useNotificationCenter, useSpotlight, userVariants, validateFile, validators, virtualListVariants, wellVariants };
+/**
+ * Password validation utilities for consistent validation across components
+ */
+interface PasswordRequirement {
+    label: string;
+    test: (password: string) => boolean;
+}
+/**
+ * Default password requirements for strong passwords
+ */
+declare const defaultPasswordRequirements: PasswordRequirement[];
+/**
+ * Calculate password strength based on requirements
+ * @returns Number between 0 and 1 representing strength
+ */
+declare function calculatePasswordStrength(password: string, requirements?: PasswordRequirement[]): number;
+/**
+ * Get password strength color based on strength percentage
+ */
+declare function getPasswordStrengthColor(strength: number): string;
+/**
+ * Get password strength label
+ */
+declare function getPasswordStrengthLabel(strength: number): string;
+
+export { Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, ActionBar, ActionBarButton, type ActionBarProps, ActionGroup, type ActionGroupItem, type ActionGroupProps, ActionSheet, type ActionSheetItem, type ActionSheetProps, Alert, AlertDescription, type AlertRadius, AlertTitle, type AlertType, type AlertVariant, type AllowDropInfo, AreaChart, type AreaChartProps, AspectRatio, Autocomplete, type AutocompleteOption, type AutocompleteProps, Avatar, AvatarFallback, AvatarGroup, type AvatarGroupItem, type AvatarGroupProps, AvatarImage, BackTop, type BackTopProps, Badge, type BadgeProps, Banner, type BannerProps, BarChart, type BarChartProps, BatteryMeter, Blockquote, type BlockquoteProps, BottomNavigation, type BottomNavigationItem, type BottomNavigationProps, Bounce, type BounceProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, COUNTRIES, Calendar, type CalendarEvent, type CalendarProps, type CalendarView, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, type CarouselItemProps, CarouselNext, CarouselPrevious, type CarouselProps, type ChartDataPoint, type CheckInfo, Checkbox, Checkmark, type CheckmarkProps, type CheckmarkSize, type CheckmarkVariant, Chip, type ChipProps, CircularProgress, CloseButton, type CloseButtonProps, Code, Collapse, type CollapseProps, Collapsible, CollapsibleContent, CollapsibleTrigger, ColorArea, type ColorAreaProps, type ColorAreaValue, ColorField, type ColorFieldProps, ColorPicker, type ColorPickerProps, ColorSlider, type ColorSliderChannel, type ColorSliderProps, ColorSwatch, ColorSwatchPicker, type ColorSwatchPickerProps, type ColorSwatchProps, ColorWheel, type ColorWheelProps, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, Confetti, type ConfettiOptions, type ConfettiProps, ConfirmDialog, type ConfirmDialogProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, ContextualHelp, type ContextualHelpProps, CopyButton, type CopyButtonProps, Counter, type CounterProps, type Country, CurrencyInput, type CurrencyInputProps, DEFAULT_COLORS, DataTable, type DataTableProps, DateField, type DateFieldProps, type DateFormat, DateInput, type DateInputProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, DefaultErrorFallback, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiskUsageMeter, type DragInfo, type DraggableConfig, Drawer, type DrawerBackdrop, DrawerBody, DrawerClose, type DrawerCollapsible, DrawerContent, DrawerDescription, DrawerFooter, DrawerGroup, DrawerGroupLabel, DrawerHeader, DrawerInset, DrawerMenu, DrawerMenuButton, DrawerMenuItem, type DrawerMode, type DrawerPlacement, type DrawerProps, DrawerProvider, DrawerSeparator, DrawerSidebar, type DrawerSidebarProps, type DrawerSize, DrawerTitle, DrawerToggle, DrawerTrigger, type DrawerVariant, type DropInfo, Dropdown, DropdownContent, type DropdownContentProps, DropdownGroup, type DropdownGroupProps, DropdownItem, type DropdownItemProps, DropdownLabel, type DropdownProps, DropdownSection, type DropdownSectionProps, DropdownSeparator, type DropdownSeparatorProps, DropdownShortcut, DropdownSub, DropdownSubContent, type DropdownSubContentProps, type DropdownSubProps, DropdownSubTrigger, type DropdownSubTriggerProps, DropdownTrigger, type DropdownTriggerProps, EMOJIS, EMOJI_CATEGORIES, EmojiPicker, type EmojiPickerProps, EmptyState, ErrorBoundary, type ErrorBoundaryProps, Expand, type ExpandInfo, type ExpandProps, FAB, type FABAction, Fade, type FadeProps, FieldContext, type FieldContextValue, type FieldState, type FileRejection, FileUpload, type FileUploadProps, type FlatCheckInfo, type FlatSelectInfo, Flip, type FlipDirection, type FlipProps, FloatingActionButton, type FloatingActionButtonProps, Form, FormContext, type FormContextValue, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, type FormFieldProps, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, type FormProps, type FormState, FullCalendar, type FullCalendarProps, Glow, type GlowProps, GridList, type GridListItem, type GridListProps, H1, type H1Props, H2, type H2Props, H3, type H3Props, H4, type H4Props, HoverCard, HoverCardContent, HoverCardTrigger, IllustratedMessage, type IllustratedMessageProps, Image, ImageCropper, type ImageCropperProps, ImageViewer, type ImageViewerProps, ImageViewerTrigger, type ImageViewerTriggerProps, Indicator, type IndicatorProps, IndicatorWrapper, type IndicatorWrapperProps, InfiniteScroll, type InfiniteScrollProps, InlineAlert, type InlineAlertProps, InlineCode, type InlineCodeProps, Input, InputOTP, InputOTPGroup, type InputOTPProps, InputOTPSeparator, InputOTPSlot, type InputOTPSlotProps, type InputProps, KanbanBoard, type KanbanBoardProps, type KanbanCard, type KanbanColumn, Kbd, type KbdProps, Label, LabeledValue, LabeledValueGroup, type LabeledValueGroupProps, type LabeledValueProps, Large, type LargeProps, Lead, type LeadProps, LineChart, type LineChartProps, Link, type LinkProps, List, type ListDataItem, ListItemComponent as ListItem, type ListItemComponentProps, ListItemText, type ListItemTextProps, type ListProps, ListView, type ListViewItem, type ListViewProps, Listbox, ListboxItem, type ListboxOption, Loading, LoadingOverlay, type LoadingOverlayProps, type LoadingProps, MASK_PRESETS, type MaskChar, type MaskDefinition, type MaskPreset, MaskedInput, type MaskedInputProps, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, Meter, type MeterProps, Modal, type ModalBackdrop, ModalBody, ModalClose, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalOverlay, type ModalPlacement, ModalPortal, type ModalProps, ModalRoot, type ModalScrollBehavior, ModalTitle, ModalTrigger, Muted, type MutedProps, NProgress, type NProgressProps, Navbar, NavbarBrand, NavbarContent, NavbarItem, NavbarLink, type NavbarProps, NavigationMenu, NavigationMenuContent, type NavigationMenuContentProps, NavigationMenuIndicator, type NavigationMenuIndicatorProps, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, type NavigationMenuLinkProps, NavigationMenuList, type NavigationMenuListProps, type NavigationMenuProps, NavigationMenuTrigger, type NavigationMenuTriggerProps, NavigationMenuViewport, type Notification, NotificationCenter, NotificationCenterContent, type NotificationCenterContentProps, type NotificationCenterProps, NotificationCenterProvider, type NotificationCenterProviderProps, NotificationCenterTrigger, type NotificationCenterTriggerProps, NotificationItem, type NotificationItemProps, NotificationList, type NotificationListProps, NumberField, type NumberFieldProps, NumberInput, type NumberInputProps, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, type PaginationState, Paragraph, type ParagraphProps, Parallax, type ParallaxProps, PasswordInput, type PasswordInputProps, type PasswordRequirement, PhoneInput, type PhoneInputProps, PieChart, type PieChartProps, Pop, type PopProps, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, Progress, PullToRefresh, type PullToRefreshProps, Pulse, type PulseProps, type PulseSpeed, QRCode, type QRCodeProps, RadioGroup, RadioGroupItem, RangeSlider, type RangeSliderProps, Rating, type RatingProps, ResizableHandle, type ResizableHandleProps, ResizablePanel, ResizablePanelGroup, type ResizablePanelGroupProps, RichTextEditor, type RichTextEditorProps, Ripple, type RippleProps, Rotate, type RotateProps, Scale, type ScaleOrigin, type ScaleProps, ScrollArea, type ScrollAreaProps, ScrollProgress, type ScrollProgressPosition, type ScrollProgressProps, ScrollReveal, type ScrollRevealDirection, type ScrollRevealProps, ScrollShadow, type ScrollShadowProps, SearchBar, type SearchBarProps, SearchField, type SearchFieldProps, type SearchSuggestion, SegmentedControl, SegmentedControlItem, type SegmentedControlItemProps, type SegmentedControlProps, Select, type SelectInfo, type SelectOption, type SelectProps, Separator, type SeparatorProps, Shake, type ShakeIntensity, type ShakeProps, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Shimmer, type ShimmerDirection, type ShimmerProps, Skeleton, Slide, type SlideDirection, type SlideProps, Slider, Small, type SmallProps, Snippet, type SortDirection, type SortState, type SortableItem, SortableList, Sparkles, type SparklesProps, Spinner, type SpotlightItem, SpotlightSearch, type SpotlightSearchProps, StatCard, StatusLight, type StatusLightProps, Step, type StepProps, Steps, type StepsProps, type SwipeAction, SwipeActions, type SwipeActionsProps, Switch, type SwitchColor, type SwitchProps, type SwitchSize, Table, TableBody, TableCaption, TableCell, type TableColumn, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, type Tag, TagGroup, type TagGroupProps, TagInput, type TagInputProps, type TagItem, TextBadge, type TextBadgeProps, TextField, type TextFieldProps, TextReveal, type TextRevealDirection, type TextRevealProps, Textarea, type TextareaProps, ThemeProvider, type ThemeProviderProps, ThemeToggle, type ThemeToggleProps, TimeField, type TimeFieldProps, TimeInput, type TimeInputProps, TimePicker, type TimePickerProps, type TimeValue, Timeline, TimelineContent, TimelineItem, TimelineOpposite, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TransitionProps, Tree, type TreeNode, type TreeProps, Typewriter, type TypewriterProps, UL, type ULProps, type UploadedFile, User, type ValidationRule, type ViewerImage, VirtualList, type VirtualListProps, Wiggle, type WiggleProps, WordRotate, type WordRotateProps, actionBarVariants, actionGroupVariants, actionSheetItemVariants, alertVariants, applyMask, autocompleteInputVariants, avatarGroupVariants, backTopVariants, badgeIndicatorVariants, bannerVariants, bottomNavigationVariants, buttonGroupVariants, buttonVariants, calculatePasswordStrength, cardVariants, carouselVariants, chartContainerVariants, chipVariants, circularProgressVariants, closeButtonVariants, cn, codeVariants, colorAreaVariants, colorFieldVariants, colorSliderVariants, colorSwatchPickerVariants, colorSwatchVariants, colorWheelVariants, confirmDialogIconVariants, contextualHelpTriggerVariants, copyButtonVariants, currencyInputVariants, dateFieldVariants, dateInputVariants, defaultPasswordRequirements, drawerMenuButtonVariants, emojiPickerVariants, emptyStateVariants, fabVariants, fileUploadVariants, formatCurrency, formatDate, formatFileSize, formatPhoneNumber, fullCalendarVariants, getFileIcon, getMaskPlaceholder, getPasswordStrengthColor, getPasswordStrengthLabel, gridListItemVariants, gridListVariants, hexToRgb, hsvToRgb, illustratedMessageVariants, imageCropperVariants, imageVariants, indicatorVariants, infiniteScrollLoaderVariants, infiniteScrollVariants, inlineAlertVariants, inputOTPVariants, inputSizeVariants, kanbanBoardVariants, kanbanCardVariants, kanbanColumnVariants, kbdVariants, labelSizeVariants, labeledValueGroupVariants, labeledValueVariants, linkVariants, listItemVariants, listVariants, listViewItemVariants, listViewVariants, listboxItemVariants, listboxVariants, loadingOverlayVariants, loadingVariants, maskedInputVariants, meterVariants, modalContentVariants, navbarVariants, navigationMenuLinkStyle, navigationMenuTriggerStyle, nprogressVariants, numberFieldVariants, parseDate, parseFormattedValue, phoneInputVariants, pullToRefreshVariants, qrCodeVariants, rangeSliderVariants, ratingVariants, rgbToHex, rgbToHsv, richTextEditorVariants, scrollShadowVariants, searchBarVariants, searchFieldVariants, segmentedControlItemVariants, segmentedControlVariants, selectVariants, sheetVariants, skeletonVariants, snippetVariants, sortableItemVariants, sortableListVariants, spinnerVariants, statCardVariants, statusLightVariants, stepVariants, stepsVariants, swipeActionVariants, swipeActionsVariants, colorMap as switchColors, tagGroupItemVariants, tagGroupVariants, tagVariants, textBadgeVariants, textFieldVariants, themeToggleVariants, timeFieldVariants, timeInputVariants, timelineItemVariants, timelineVariants, toggleVariants, treeItemVariants, treeVariants, unmask, useAnimatedValue, useAsync, useAsyncRetry, useBodyScrollLock, useBooleanToggle, useBreakpoint, useBreakpoints, useButtonGroup, useCarousel, useClickOutside, useClickOutsideMultiple, useConfetti, useConfirmDialog, useCopy, useCopyToClipboard, useCountdown, useCounter, useCycle, useDebounce, useDebouncedCallback, useDebouncedCallbackWithControls, useDelayedValue, useDisclosure, useDisclosureOpen, useDistance, useDocumentIsVisible, useDocumentVisibility, useDocumentVisibilityCallback, useDrawer, useElementSize, useEventListener, useEventListenerRef, useFetch, useFieldContext, useFocusTrap, useFocusTrapRef, useFormContext, useFullscreen, useFullscreenRef, useGeolocation, useHotkeys, useHotkeysMap, useHover, useHoverDelay, useHoverProps, useHoverRef, useIdle, useIdleCallback, useIncrementCounter, useIntersectionObserver, useIntersectionObserverRef, useInterval, useIntervalControls, useIsDesktop, useIsMobile, useIsTablet, useKeyPress, useKeyPressed, useKeyboardShortcut, useLazyLoad, useList, useLocalStorage, useLongPress, useMap, useMediaPermission, useMediaQuery, useMouse, useMouseElement, useMouseElementRef, useMutation, useMutationObserver, useMutationObserverRef, useNotificationCenter, useNotificationPermission, useOnlineStatus, useOnlineStatusCallback, usePermission, usePrefersColorScheme, usePrefersReducedMotion, usePrevious, usePreviousDistinct, usePreviousWithInitial, useQueue, useRafLoop, useRecord, useResizeObserver, useResizeObserverRef, useScrollLock, useScrollPosition, useSelection, useSessionStorage, useSet, useSpeechRecognition, useSpeechSynthesis, useSpotlight, useSpringValue, useStack, useThrottle, useThrottledCallback, useTimeout, useTimeoutControls, useTimeoutFlag, useTimer, useToggle, useWindowHeight, useWindowScroll, useWindowSize, useWindowWidth, userVariants, validateFile, validators, virtualListVariants };