@nkanish/liquidglass-ui 0.0.0-stage → 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,722 @@
+import * as react from 'react';
+import { ReactNode, HTMLAttributes, ButtonHTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes, ElementType, RefObject } from 'react';
+
+type Theme = 'light' | 'dark' | 'system';
+type ResolvedTheme = 'light' | 'dark';
+interface RefractionConfig {
+    enabled: boolean;
+    depth: number;
+    dome: number;
+    shine: number;
+    lightAngle: number;
+}
+interface GlassConfig {
+    blur?: number;
+    saturation?: number;
+    bendStrength?: number;
+    accentColor?: string;
+    reducedMotion?: boolean;
+    reducedTransparency?: boolean;
+    refraction?: Partial<RefractionConfig>;
+}
+interface GlassContextValue {
+    theme: Theme;
+    resolvedTheme: ResolvedTheme;
+    setTheme: (theme: Theme) => void;
+    config: GlassConfig;
+    setConfig: (config: Partial<GlassConfig>) => void;
+    refraction: RefractionConfig;
+}
+interface GlassProviderProps {
+    children: ReactNode;
+    defaultTheme?: Theme;
+    config?: GlassConfig;
+    storageKey?: string;
+}
+declare function GlassProvider({ children, defaultTheme, config: initialConfig, storageKey, }: GlassProviderProps): react.JSX.Element;
+declare function useGlass(): GlassContextValue;
+declare function useTheme(): Pick<GlassContextValue, 'theme' | 'resolvedTheme' | 'setTheme'>;
+declare function useRefraction(): RefractionConfig;
+
+interface GlassProps extends HTMLAttributes<HTMLDivElement> {
+    /** Visual variant */
+    variant?: 'default' | 'elevated' | 'subtle' | 'solid';
+    /** Blur intensity in pixels */
+    blur?: number;
+    /** Color saturation multiplier */
+    saturation?: number;
+    /** Custom tint color */
+    tint?: string;
+    /** Enable pointer tracking for highlight effect */
+    interactive?: boolean;
+    /** Show rim light gradient (legacy, superseded by refraction) */
+    rimLight?: boolean;
+    /**
+     * Enable glisse-style edge refraction with chromatic aberration and specular highlights.
+     * Defaults to true. Set to false to disable.
+     */
+    refraction?: boolean;
+    /** Refraction depth in pixels from edge. Default: 8 */
+    refractionDepth?: number;
+    /** Dome curvature for lens effect. Default: 4 */
+    refractionDome?: number;
+    /** Specular shine intensity (-2 to 2). Default: 0.3 */
+    shine?: number;
+    /** Light angle in degrees for rim and refraction. Default: 225 */
+    lightAngle?: number;
+}
+declare const Glass: react.ForwardRefExoticComponent<GlassProps & react.RefAttributes<HTMLDivElement>>;
+
+interface GlassCardProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'elevated' | 'outlined';
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    radius?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    hoverable?: boolean;
+    /** Disable glisse refraction effect. Defaults to false (refraction enabled). */
+    disableRefraction?: boolean;
+}
+declare const GlassCard: react.ForwardRefExoticComponent<GlassCardProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'glass' | 'filled' | 'outlined' | 'ghost';
+    size?: 'sm' | 'md' | 'lg';
+    icon?: ReactNode;
+    iconPosition?: 'start' | 'end';
+    destructive?: boolean;
+    tint?: string;
+    loading?: boolean;
+    fullWidth?: boolean;
+    /** Disable glisse refraction effect. Defaults to false (refraction enabled for glass variant). */
+    disableRefraction?: boolean;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    icon: ReactNode;
+    variant?: 'glass' | 'filled' | 'ghost';
+    size?: 'sm' | 'md' | 'lg';
+    destructive?: boolean;
+    tint?: string;
+    loading?: boolean;
+    'aria-label': string;
+}
+declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ToggleProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'default' | 'outline';
+    icon?: ReactNode;
+}
+declare const Toggle: react.ForwardRefExoticComponent<ToggleProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange' | 'size'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    icon?: ReactNode;
+    rightElement?: ReactNode;
+    size?: 'sm' | 'md' | 'lg';
+    error?: boolean;
+    clearable?: boolean;
+    onClear?: () => void;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'value' | 'defaultValue' | 'onChange'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    error?: boolean;
+    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
+}
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+type SearchFieldProps = Omit<InputProps, 'type' | 'icon'>;
+declare const SearchField: react.ForwardRefExoticComponent<SearchFieldProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SelectOption {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+}
+interface SelectProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'defaultValue' | 'onChange'> {
+    options: SelectOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    size?: 'sm' | 'md' | 'lg';
+    error?: boolean;
+}
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'checked' | 'defaultChecked' | 'onChange' | 'size'> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    label?: string;
+    size?: 'sm' | 'md' | 'lg';
+    indeterminate?: boolean;
+}
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface RadioGroupProps {
+    children: ReactNode;
+    name: string;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+}
+declare function RadioGroup({ children, name, value: controlledValue, defaultValue, onValueChange, disabled, size, orientation, className, }: RadioGroupProps): react.JSX.Element;
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    label?: string;
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'defaultValue' | 'onChange'> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    /** Visual scale. `md` matches glisse exactly. */
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'value' | 'defaultValue' | 'onChange'> {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+}
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TabBarItem {
+    value: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    href?: string;
+}
+interface TabBarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'> {
+    items: TabBarItem[];
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string) => void;
+    link?: ElementType;
+    showLabels?: boolean;
+}
+declare const TabBar: react.ForwardRefExoticComponent<TabBarProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SegmentedControlItem {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+}
+interface SegmentedControlProps extends Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'> {
+    items: SegmentedControlItem[];
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string) => void;
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const SegmentedControl: react.ForwardRefExoticComponent<SegmentedControlProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TabsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const Tabs: react.ForwardRefExoticComponent<TabsProps & react.RefAttributes<HTMLDivElement>>;
+interface TabsListProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const TabsList: react.ForwardRefExoticComponent<TabsListProps & react.RefAttributes<HTMLDivElement>>;
+interface TabsTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+    value: string;
+    disabled?: boolean;
+    children: ReactNode;
+}
+declare const TabsTrigger: react.ForwardRefExoticComponent<TabsTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+interface TabsContentProps extends HTMLAttributes<HTMLDivElement> {
+    value: string;
+    children: ReactNode;
+}
+declare const TabsContent: react.ForwardRefExoticComponent<TabsContentProps & react.RefAttributes<HTMLDivElement>>;
+
+interface NavbarProps extends HTMLAttributes<HTMLElement> {
+    logo?: ReactNode;
+    children?: ReactNode;
+    actions?: ReactNode;
+    sticky?: boolean;
+    bordered?: boolean;
+}
+declare const Navbar: react.ForwardRefExoticComponent<NavbarProps & react.RefAttributes<HTMLElement>>;
+interface NavbarLinkProps extends HTMLAttributes<HTMLAnchorElement> {
+    href: string;
+    active?: boolean;
+    children: ReactNode;
+}
+declare const NavbarLink: react.ForwardRefExoticComponent<NavbarLinkProps & react.RefAttributes<HTMLAnchorElement>>;
+
+interface SidebarContextValue {
+    isCollapsed: boolean;
+    toggleCollapsed: () => void;
+    setCollapsed: (collapsed: boolean) => void;
+}
+declare function useSidebar(): SidebarContextValue;
+interface SidebarProviderProps {
+    children: ReactNode;
+    defaultCollapsed?: boolean;
+}
+declare function SidebarProvider({ children, defaultCollapsed }: SidebarProviderProps): react.JSX.Element;
+interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    children: ReactNode;
+    width?: number;
+    collapsedWidth?: number;
+}
+declare const Sidebar: react.ForwardRefExoticComponent<SidebarProps & react.RefAttributes<HTMLElement>>;
+interface SidebarHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const SidebarHeader: react.ForwardRefExoticComponent<SidebarHeaderProps & react.RefAttributes<HTMLDivElement>>;
+interface SidebarContentProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const SidebarContent: react.ForwardRefExoticComponent<SidebarContentProps & react.RefAttributes<HTMLDivElement>>;
+interface SidebarItemProps {
+    icon?: ReactNode;
+    label: string;
+    active?: boolean;
+    href?: string;
+    onClick?: () => void;
+    className?: string;
+}
+declare const SidebarItem: react.ForwardRefExoticComponent<SidebarItemProps & react.RefAttributes<HTMLButtonElement>>;
+interface SidebarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    children: ReactNode;
+}
+declare const SidebarGroup: react.ForwardRefExoticComponent<SidebarGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DockItem {
+    id: string;
+    icon: ReactNode;
+    label: string;
+    onClick?: () => void;
+    href?: string;
+    badge?: number;
+}
+interface DockProps extends HTMLAttributes<HTMLDivElement> {
+    items: DockItem[];
+    magnification?: number;
+    distance?: number;
+    direction?: 'bottom' | 'left' | 'right';
+}
+declare const Dock: react.ForwardRefExoticComponent<DockProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ModalProps extends HTMLAttributes<HTMLDivElement> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    title?: string;
+    description?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+    showCloseButton?: boolean;
+    /** Disable glisse refraction effect. Defaults to false (refraction enabled). */
+    disableRefraction?: boolean;
+}
+declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDivElement>>;
+interface ModalFooterProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const ModalFooter: react.ForwardRefExoticComponent<ModalFooterProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SheetProps extends HTMLAttributes<HTMLDivElement> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    side?: 'bottom' | 'top' | 'left' | 'right';
+    size?: 'sm' | 'md' | 'lg' | 'full';
+    showHandle?: boolean;
+    /** Disable glisse refraction effect. Defaults to false (refraction enabled). */
+    disableRefraction?: boolean;
+}
+declare const Sheet: react.ForwardRefExoticComponent<SheetProps & react.RefAttributes<HTMLDivElement>>;
+
+interface MenuItem {
+    label: ReactNode;
+    icon?: ReactNode;
+    onSelect?: () => void;
+    destructive?: boolean;
+    disabled?: boolean;
+    shortcut?: string;
+}
+type MenuEntry = MenuItem | 'separator';
+interface MenuProps extends HTMLAttributes<HTMLDivElement> {
+    items: MenuEntry[];
+    trigger: ReactNode;
+    align?: 'start' | 'end';
+}
+declare const Menu: react.ForwardRefExoticComponent<MenuProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TooltipProps {
+    content: ReactNode;
+    children: ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    delay?: number;
+    disabled?: boolean;
+}
+declare function Tooltip({ content, children, side, align, delay, disabled, }: TooltipProps): react.JSX.Element;
+
+interface ToastProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'success' | 'warning' | 'error' | 'info';
+    title?: string;
+    description?: string;
+    icon?: ReactNode;
+    action?: ReactNode;
+    duration?: number;
+    onClose?: () => void;
+}
+declare const Toast: react.ForwardRefExoticComponent<ToastProps & react.RefAttributes<HTMLDivElement>>;
+interface ToastData extends Omit<ToastProps, 'onClose'> {
+    id: string;
+}
+interface ToastContextValue {
+    toasts: ToastData[];
+    toast: (props: Omit<ToastData, 'id'>) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+}
+declare function ToastProvider({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useToast(): Omit<ToastContextValue, 'toasts'>;
+
+interface AlertProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'info' | 'success' | 'warning' | 'error';
+    title?: string;
+    icon?: ReactNode;
+    action?: ReactNode;
+    onClose?: () => void;
+}
+declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+    variant?: 'linear' | 'circular';
+    size?: 'sm' | 'md' | 'lg';
+    color?: string;
+    showValue?: boolean;
+    indeterminate?: boolean;
+}
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SpinnerProps extends HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg' | number;
+    color?: string;
+    thickness?: number;
+    label?: string;
+}
+declare const Spinner: react.ForwardRefExoticComponent<SpinnerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    variant?: 'default' | 'secondary' | 'success' | 'warning' | 'destructive' | 'outline';
+    size?: 'sm' | 'md' | 'lg';
+    dot?: boolean;
+    icon?: ReactNode;
+}
+declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface AvatarProps extends HTMLAttributes<HTMLDivElement> {
+    src?: string;
+    alt?: string;
+    fallback?: ReactNode;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    shape?: 'circle' | 'square';
+    status?: 'online' | 'offline' | 'busy' | 'away';
+}
+declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ChipProps extends HTMLAttributes<HTMLSpanElement> {
+    variant?: 'filled' | 'outlined' | 'glass';
+    size?: 'sm' | 'md' | 'lg';
+    color?: string;
+    icon?: ReactNode;
+    onRemove?: () => void;
+    removable?: boolean;
+    selected?: boolean;
+    onClick?: () => void;
+}
+declare const Chip: react.ForwardRefExoticComponent<ChipProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface AccordionProps extends HTMLAttributes<HTMLDivElement> {
+    type?: 'single' | 'multiple';
+    defaultValue?: string | string[];
+    collapsible?: boolean;
+}
+declare const Accordion: react.ForwardRefExoticComponent<AccordionProps & react.RefAttributes<HTMLDivElement>>;
+interface AccordionItemProps extends HTMLAttributes<HTMLDivElement> {
+    value: string;
+    disabled?: boolean;
+}
+declare const AccordionItem: react.ForwardRefExoticComponent<AccordionItemProps & react.RefAttributes<HTMLDivElement>>;
+interface AccordionTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+    children: ReactNode;
+}
+declare const AccordionTrigger: react.ForwardRefExoticComponent<AccordionTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+interface AccordionContentProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const AccordionContent: react.ForwardRefExoticComponent<AccordionContentProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SeparatorProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+    decorative?: boolean;
+}
+declare const Separator: react.ForwardRefExoticComponent<SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: 'text' | 'circular' | 'rectangular' | 'rounded';
+    width?: number | string;
+    height?: number | string;
+    animation?: 'pulse' | 'wave' | 'none';
+}
+declare const Skeleton: react.ForwardRefExoticComponent<SkeletonProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DrawerProps extends HTMLAttributes<HTMLDivElement> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    side?: 'left' | 'right';
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    title?: string;
+    description?: string;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+}
+declare const Drawer: react.ForwardRefExoticComponent<DrawerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface PopoverProps {
+    children: ReactNode;
+    content: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    defaultOpen?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    sideOffset?: number;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+    trigger?: 'click' | 'hover';
+}
+declare function Popover({ children, content, open: controlledOpen, onOpenChange, defaultOpen, side, align, sideOffset, closeOnClickOutside, closeOnEscape, trigger, }: PopoverProps): react.JSX.Element;
+
+interface ContextMenuItem {
+    label: ReactNode;
+    icon?: ReactNode;
+    onSelect?: () => void;
+    destructive?: boolean;
+    disabled?: boolean;
+    shortcut?: string;
+}
+type ContextMenuEntry = ContextMenuItem | 'separator';
+interface ContextMenuProps {
+    children: ReactNode;
+    items: ContextMenuEntry[];
+    disabled?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function ContextMenu({ children, items, disabled, onOpenChange, }: ContextMenuProps): react.JSX.Element;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    onSelect: () => void;
+    keywords?: string[];
+    group?: string;
+    disabled?: boolean;
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    items: CommandItem[];
+    placeholder?: string;
+    emptyMessage?: string;
+    groups?: Record<string, string>;
+}
+declare function CommandPalette({ open, onOpenChange, items, placeholder, emptyMessage, groups, }: CommandPaletteProps): react.ReactPortal | null;
+
+interface CarouselProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    autoPlay?: boolean;
+    autoPlayInterval?: number;
+    showDots?: boolean;
+    showArrows?: boolean;
+    loop?: boolean;
+    slidesToShow?: number;
+    gap?: number;
+}
+declare const Carousel: react.ForwardRefExoticComponent<CarouselProps & react.RefAttributes<HTMLDivElement>>;
+
+interface FloatingActionButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    icon: ReactNode;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'primary' | 'secondary' | 'glass';
+    position?: 'bottom-right' | 'bottom-left' | 'bottom-center' | 'top-right' | 'top-left';
+    extended?: boolean;
+    label?: string;
+    'aria-label': string;
+}
+declare const FloatingActionButton: react.ForwardRefExoticComponent<FloatingActionButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface DatePickerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'value' | 'defaultValue' | 'onChange'> {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onValueChange?: (date: Date | null) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    locale?: string;
+    formatDate?: (date: Date) => string;
+}
+declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLDivElement>>;
+
+declare function useReducedMotion(): boolean;
+
+declare function useReducedTransparency(): boolean;
+
+interface PointerPosition {
+    x: number;
+    y: number;
+    percentX: number;
+    percentY: number;
+    isInside: boolean;
+}
+declare function usePointerPosition(ref: RefObject<HTMLElement | null>, options?: {
+    enabled?: boolean;
+}): PointerPosition;
+
+declare function useMounted(): boolean;
+
+interface UseControllableOptions<T> {
+    value?: T;
+    defaultValue?: T;
+    onChange?: (value: T) => void;
+}
+declare function useControllable<T>(options: UseControllableOptions<T>): [T | undefined, (value: T) => void, boolean];
+
+interface UsePressedStateOptions {
+    disabled?: boolean;
+    onPressStart?: () => void;
+    onPressEnd?: () => void;
+}
+interface PressedState {
+    isPressed: boolean;
+    pressHandlers: {
+        onPointerDown: (e: React.PointerEvent) => void;
+        onPointerUp: (e: React.PointerEvent) => void;
+        onPointerCancel: (e: React.PointerEvent) => void;
+        onPointerLeave: (e: React.PointerEvent) => void;
+        onKeyDown: (e: React.KeyboardEvent) => void;
+        onKeyUp: (e: React.KeyboardEvent) => void;
+    };
+}
+declare function usePressedState(options?: UsePressedStateOptions): PressedState;
+
+declare function useId(providedId?: string): string;
+
+/**
+ * Glisse-compatible glass refraction effect hook
+ *
+ * Based on glisse (MIT License)
+ * https://github.com/0kzh/glisse
+ * Copyright (c) 2024 Kelvin Zhang
+ */
+
+interface UseGlisseEffectOptions {
+    enabled?: boolean;
+    depth?: number;
+    dome?: number;
+    splay?: number;
+    shine?: number;
+    density?: number;
+    lightAngle?: number;
+}
+interface GlisseEffectResult {
+    filterUrl: string | null;
+    rimGradient: string;
+    isReady: boolean;
+}
+declare function useGlisseEffect(ref: RefObject<HTMLElement | null>, options?: UseGlisseEffectOptions): GlisseEffectResult;
+declare function clearGlisseCache(): void;
+
+/**
+ * SVG Filter System for Liquid Glass Refraction Effects
+ * Creates dynamic SVG filters for lens/refraction effects
+ */
+interface RefractionFilterOptions {
+    bendStrength?: number;
+    dispersion?: number;
+    blur?: number;
+    brightness?: number;
+    saturation?: number;
+    rimShine?: number;
+}
+interface GlassFilterResult {
+    id: string;
+    remove: () => void;
+    update: (options: Partial<RefractionFilterOptions>) => void;
+}
+declare function createRefractionFilter(options?: RefractionFilterOptions): GlassFilterResult;
+interface LensFilterOptions {
+    bendX?: number;
+    bendY?: number;
+    dispersion?: number;
+    chromatic?: boolean;
+}
+declare function createLensFilter(options?: LensFilterOptions): GlassFilterResult;
+interface RimLightOptions {
+    intensity?: number;
+    angle?: number;
+    spread?: number;
+}
+declare function createRimLightGradient(options?: RimLightOptions): string;
+declare function createSpecularHighlight(x: number, y: number, radius?: number, intensity?: number): string;
+declare function cleanupFilters(): void;
+declare function supportsBackdropFilter(): boolean;
+declare function supportsSVGFilters(): boolean;
+
+type ClassValue = string | number | boolean | undefined | null | ClassValue[];
+declare function cn(...inputs: ClassValue[]): string;
+
+declare function clamp(value: number, min: number, max: number): number;
+declare function lerp(start: number, end: number, t: number): number;
+declare function mapRange(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+declare function noop(): void;
+declare function isServer(): boolean;
+declare function isBrowser(): boolean;
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, Alert, type AlertProps, Avatar, type AvatarProps, Badge, type BadgeProps, Button, type ButtonProps, Carousel, type CarouselProps, Checkbox, type CheckboxProps, Chip, type ChipProps, type CommandItem, CommandPalette, type CommandPaletteProps, ContextMenu, type ContextMenuItem, type ContextMenuProps, DatePicker, type DatePickerProps, Dock, type DockItem, type DockProps, Drawer, type DrawerProps, FloatingActionButton as FAB, FloatingActionButton, type FloatingActionButtonProps, Glass, GlassCard, type GlassCardProps, type GlassConfig, type GlassContextValue, type GlassFilterResult, type GlassProps, GlassProvider, type GlassProviderProps, type GlisseEffectResult, IconButton, type IconButtonProps, Input, type InputProps, type LensFilterOptions, Menu, type MenuEntry, type MenuItem, type MenuProps, Modal, ModalFooter, type ModalFooterProps, type ModalProps, Navbar, NavbarLink, type NavbarLinkProps, type NavbarProps, Popover, type PopoverProps, Progress, type ProgressProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, type RefractionConfig, type RefractionFilterOptions, type ResolvedTheme, type RimLightOptions, SearchField, type SearchFieldProps, SegmentedControl, type SegmentedControlItem, type SegmentedControlProps, Select, type SelectOption, type SelectProps, Separator, type SeparatorProps, Sheet, type SheetProps, Sidebar, SidebarContent, type SidebarContentProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarProvider, type SidebarProviderProps, Skeleton, type SkeletonProps, Slider, type SliderProps, Spinner, type SpinnerProps, Switch, type SwitchProps, TabBar, type TabBarItem, type TabBarProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, type TextareaProps, type Theme, Toast, type ToastProps, ToastProvider, Toggle, type ToggleProps, Tooltip, type TooltipProps, type UseGlisseEffectOptions, clamp, cleanupFilters, clearGlisseCache, cn, createLensFilter, createRefractionFilter, createRimLightGradient, createSpecularHighlight, debounce, isBrowser, isServer, lerp, mapRange, noop, supportsBackdropFilter, supportsSVGFilters, throttle, useControllable, useGlass, useGlisseEffect, useId, useMounted, usePointerPosition, usePressedState, useReducedMotion, useReducedTransparency, useRefraction, useSidebar, useTheme, useToast };