@lzzjokerzzl/react-ui-components 1.1.1 → 1.2.0

package/dist/index.d.ts

@@ -1 +1,3525 @@
-export {}
+import { AnchorHTMLAttributes } from 'react';
+import { ChangeEvent } from 'react';
+import { ComponentPropsWithoutRef } from 'react';
+import { default as default_2 } from 'react';
+import { ElementType } from 'react';
+import { FocusEvent as FocusEvent_2 } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributes } from 'react';
+import { HTMLMotionProps } from 'framer-motion';
+import { JSX } from 'react/jsx-runtime';
+import { Key } from 'react';
+import { KeyboardEvent as KeyboardEvent_2 } from 'react';
+import { LegacyAnimationControls } from 'motion-dom';
+import { MotionProps } from 'framer-motion';
+import { MotionValue } from 'motion-dom';
+import { MouseEvent as MouseEvent_2 } from 'react';
+import * as React_2 from 'react';
+import { ReactEventHandler } from 'react';
+import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { RefAttributes } from 'react';
+import { RefObject } from 'react';
+import { Transition } from 'framer-motion';
+import { Variants } from 'framer-motion';
+
+/**
+ * Main Accordion component that provides accordion functionality with HeroUI styling
+ */
+export declare const Accordion: default_2.FC<AccordionProps>;
+
+/**
+ * Animation configuration for accordion components
+ */
+declare interface AccordionAnimationConfig {
+    /** Animation preset */
+    preset?: AccordionAnimationPreset;
+    /** Custom spring configuration */
+    spring?: {
+        stiffness?: number;
+        damping?: number;
+        duration?: number;
+    };
+    /** Stagger delay between items (in seconds) */
+    staggerDelay?: number;
+    /** Enable stagger animation for multiple items */
+    enableStagger?: boolean;
+}
+
+/**
+ * Animation preset types for framer-motion
+ */
+declare type AccordionAnimationPreset = "spring" | "tween" | "smooth" | "bouncy" | "slow";
+
+/**
+ * Color variants for Accordion component
+ */
+export declare type AccordionColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * Accordion content component with smooth animations
+ */
+export declare const AccordionContent: default_2.FC<AccordionContentProps>;
+
+/**
+ * Props for AccordionContent component
+ */
+export declare interface AccordionContentProps {
+    /** Content to display */
+    children: ReactNode;
+    /** Whether the content is expanded */
+    isExpanded: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom styles */
+    style?: React.CSSProperties;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Accordion header component with click handling and accessibility
+ */
+export declare const AccordionHeader: default_2.FC<AccordionHeaderProps>;
+
+/**
+ * Props for AccordionHeader component
+ */
+export declare interface AccordionHeaderProps {
+    /** Header content */
+    children: ReactNode;
+    /** Whether the item is expanded */
+    isExpanded: boolean;
+    /** Whether the item is disabled */
+    isDisabled?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+    /** ARIA label */
+    ariaLabel?: string;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Indicator positions for the expand/collapse icon
+ */
+declare type AccordionIndicatorPlacement = "start" | "end";
+
+/**
+ * Individual accordion item component
+ */
+export declare const AccordionItem: default_2.FC<AccordionItemProps>;
+
+/**
+ * Individual accordion item configuration
+ */
+declare interface AccordionItemConfig {
+    /** Unique key for the item */
+    key: string;
+    /** Title content for the header */
+    title: ReactNode;
+    /** Content to display when expanded */
+    content: ReactNode;
+    /** Whether this item starts expanded */
+    defaultExpanded?: boolean;
+    /** Whether this item is disabled */
+    isDisabled?: boolean;
+    /** Custom header content */
+    header?: ReactNode;
+    /** ARIA label for the item */
+    ariaLabel?: string;
+    /** Additional CSS classes for the item */
+    className?: string;
+    /** Custom styles for the item */
+    style?: React.CSSProperties;
+}
+
+/**
+ * Item placement positions
+ */
+declare type AccordionItemPlacement = "start" | "end" | "outside";
+
+/**
+ * Props for individual AccordionItem component
+ */
+export declare interface AccordionItemProps {
+    /** Unique identifier for the item */
+    itemKey: string;
+    /** Title content for the header */
+    title: ReactNode;
+    /** Content to display when expanded */
+    children: ReactNode;
+    /** Whether this item is expanded */
+    isExpanded?: boolean;
+    /** Whether this item is disabled */
+    isDisabled?: boolean;
+    /** Whether to show divider */
+    showDivider?: boolean;
+    /** Custom header content */
+    header?: ReactNode;
+    /** Click handler for the item */
+    onToggle?: (key: string) => void;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom styles */
+    style?: React.CSSProperties;
+    /** ARIA label for accessibility */
+    ariaLabel?: string;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Main accordion component props
+ */
+export declare interface AccordionProps {
+    /** Accordion items configuration */
+    items?: AccordionItemConfig[];
+    /** Children components (AccordionItem) */
+    children?: ReactNode;
+    /** Selection mode */
+    selectionMode?: AccordionSelectionMode;
+    /** Default expanded items (for uncontrolled) */
+    defaultExpandedKeys?: string[];
+    /** Expanded items (for controlled) */
+    expandedKeys?: string[];
+    /** Callback when expansion changes */
+    onExpandedChange?: (keys: string[]) => void;
+    /** Callback when a single selection changes */
+    onSelectionChange?: (key: string) => void;
+    /** Size variant */
+    size?: AccordionSize;
+    /** Color variant */
+    color?: AccordionColor;
+    /** Visual variant */
+    variant?: AccordionVariant;
+    /** Border radius */
+    radius?: AccordionRadius;
+    /** Whether the accordion is disabled */
+    isDisabled?: boolean;
+    /** Whether to show dividers between items */
+    showDivider?: boolean;
+    /** Whether to disable animations */
+    disableAnimation?: boolean;
+    /** Whether to disable the indicator icons */
+    disableIndicatorAnimation?: boolean;
+    /** Whether to keep content mounted when collapsed */
+    keepContentMounted?: boolean;
+    /** Animation configuration for framer-motion */
+    animationConfig?: AccordionAnimationConfig;
+    /** Indicator placement */
+    indicatorPlacement?: AccordionIndicatorPlacement;
+    /** Item placement */
+    itemPlacement?: AccordionItemPlacement;
+    /** Whether to compact mode */
+    isCompact?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom styles */
+    style?: React.CSSProperties;
+    /** ARIA label for the accordion */
+    "aria-label"?: string;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Border radius variants for Accordion component
+ */
+export declare type AccordionRadius = "none" | "sm" | "md" | "lg" | "xl" | "full";
+
+/**
+ * Selection modes for Accordion
+ */
+export declare type AccordionSelectionMode = "single" | "multiple" | "none";
+
+/**
+ * Size variants for Accordion component
+ */
+export declare type AccordionSize = "xs" | "sm" | "md" | "lg" | "xl";
+
+/**
+ * Visual variants for Accordion component
+ */
+export declare type AccordionVariant = "flat" | "bordered" | "shadow" | "splitted";
+
+export declare interface AnimatedContainerConfig {
+    respectReducedMotion?: boolean;
+    defaultDuration?: number;
+    defaultEasing?: EasingType;
+    defaultTrigger?: TriggerType;
+    debugMode?: boolean;
+}
+
+declare type AnimationIntensity = 'low' | 'medium' | 'high';
+
+declare type AnimationType = 'fadeIn' | 'slideIn' | 'scaleIn' | 'rotateIn' | 'bounce' | 'stagger';
+
+export declare interface AnimationVariants {
+    initial: any;
+    animate: any;
+    exit?: any;
+    hover?: any;
+    tap?: any;
+}
+
+/**
+ * Main Autocomplete component following HeroUI design system
+ */
+export declare const Autocomplete: ForwardRefExoticComponent<AutocompleteProps<AutocompleteItemData> & RefAttributes<HTMLDivElement>>;
+
+/**
+ * Autocomplete color variants following HeroUI design system
+ */
+declare type AutocompleteColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+
+/**
+ * AutocompleteItem component for individual list items in the autocomplete dropdown
+ */
+export declare const AutocompleteItem: default_2.ForwardRefExoticComponent<AutocompleteItemProps & {
+    /** Whether this item is currently selected */
+    isSelected?: boolean;
+    /** Whether this item is currently focused */
+    isFocused?: boolean;
+    /** Whether this item is disabled */
+    isDisabled?: boolean;
+    /** Whether to show divider after this item */
+    showDivider?: boolean;
+    /** Current autocomplete variant for styling context */
+    variant?: "flat" | "bordered" | "faded" | "solid" | "light" | "shadow";
+    /** Current autocomplete color for styling context */
+    color?: "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+    /** Current autocomplete size for styling context */
+    size?: "sm" | "md" | "lg";
+    /** Item key for selection handling */
+    itemKey?: Key;
+    /** Selection handler */
+    onSelectionChange?: (key: Key) => void;
+} & default_2.RefAttributes<HTMLLIElement>>;
+
+/**
+ * Generic item type for collections
+ */
+declare interface AutocompleteItemData {
+    key: Key;
+    label: string;
+    value?: string;
+    description?: string;
+    isDisabled?: boolean;
+    startContent?: ReactNode;
+    endContent?: ReactNode;
+    className?: string;
+    textValue?: string;
+}
+
+/**
+ * AutocompleteItem component props
+ */
+export declare interface AutocompleteItemProps extends ComponentPropsWithoutRef<"li"> {
+    /** Unique key for the item */
+    key?: Key;
+    /** Item text value for filtering */
+    textValue?: string;
+    /** Start content */
+    startContent?: ReactNode;
+    /** End content */
+    endContent?: ReactNode;
+    /** Description text */
+    description?: ReactNode;
+    /** Custom class names for slots */
+    classNames?: Partial<Record<keyof AutocompleteItemSlots, string>>;
+    /** Event handlers */
+    onPress?: () => void;
+    onPressStart?: () => void;
+    onPressEnd?: () => void;
+}
+
+/**
+ * AutocompleteItem slots
+ */
+declare interface AutocompleteItemSlots {
+    /** Base wrapper for the item */
+    base: string;
+    /** Content wrapper */
+    wrapper: string;
+    /** Title text */
+    title: string;
+    /** Description text */
+    description: string;
+    /** Start content wrapper */
+    startContent: string;
+    /** End content wrapper */
+    endContent: string;
+}
+
+/**
+ * Autocomplete label placement options
+ */
+declare type AutocompleteLabelPlacement = 'inside' | 'outside' | 'outside-left';
+
+/**
+ * Base Autocomplete component props
+ */
+export declare interface AutocompleteProps<T = AutocompleteItemData> extends Omit<ComponentPropsWithoutRef<"input">, "color" | "size" | "children" | "onChange" | "onSelect"> {
+    /** Content items (for static lists) */
+    children?: ReactNode;
+    /** Label for the autocomplete */
+    label?: ReactNode;
+    /** Visual variant */
+    variant?: AutocompleteVariant;
+    /** Color theme */
+    color?: AutocompleteColor;
+    /** Size variant */
+    size?: AutocompleteSize;
+    /** Items collection (for dynamic lists) */
+    items?: Iterable<T>;
+    /** Default items for uncontrolled usage */
+    defaultItems?: Iterable<T>;
+    /** Controlled input value */
+    inputValue?: string;
+    /** Default input value for uncontrolled usage */
+    defaultInputValue?: string;
+    /** Allow custom values not in the list */
+    allowsCustomValue?: boolean;
+    /** Allow empty collections */
+    allowsEmptyCollection?: boolean;
+    /** Close popover on blur */
+    shouldCloseOnBlur?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Description text */
+    description?: ReactNode;
+    /** When to trigger menu opening */
+    menuTrigger?: MenuTriggerAction;
+    /** Label placement */
+    labelPlacement?: AutocompleteLabelPlacement;
+    /** Controlled selected key */
+    selectedKey?: Key;
+    /** Default selected key for uncontrolled usage */
+    defaultSelectedKey?: Key;
+    /** Disabled item keys */
+    disabledKeys?: 'all' | Key[];
+    /** Error message */
+    errorMessage?: ReactNode | ((v: ValidationResult_2) => ReactNode);
+    /** Validation function */
+    validate?: (value: {
+        inputValue: string;
+        selectedKey: Key;
+    }) => ValidationError_2 | true | null | undefined;
+    /** Validation behavior */
+    validationBehavior?: ValidationBehavior_2;
+    /** Start content */
+    startContent?: ReactNode;
+    /** End content */
+    endContent?: ReactNode;
+    /** Auto focus */
+    autoFocus?: boolean;
+    /** Custom filter function */
+    defaultFilter?: FilterFunction;
+    /** Filter options for Intl.Collator */
+    filterOptions?: Intl.CollatorOptions;
+    /** Maximum listbox height for virtualization */
+    maxListboxHeight?: number;
+    /** Item height for virtualization */
+    itemHeight?: number;
+    /** Enable virtualization */
+    isVirtualized?: boolean;
+    /** Read-only state */
+    isReadOnly?: boolean;
+    /** Required state */
+    isRequired?: boolean;
+    /** Invalid state */
+    isInvalid?: boolean;
+    /** Disabled state */
+    isDisabled?: boolean;
+    /** Full width */
+    fullWidth?: boolean;
+    /** Custom selector icon */
+    selectorIcon?: ReactNode;
+    /** Custom clear icon */
+    clearIcon?: ReactNode;
+    /** Show scroll indicators */
+    showScrollIndicators?: boolean;
+    /** Allow clearing */
+    isClearable?: boolean;
+    /** Disable animations */
+    disableAnimation?: boolean;
+    /** Disable selector icon rotation */
+    disableSelectorIconRotation?: boolean;
+    /** Custom class names for slots */
+    classNames?: Partial<Record<keyof AutocompleteSlots, string>>;
+    /** Custom popover props */
+    popoverProps?: ComponentPropsWithoutRef<"div"> & {
+        isOpen?: boolean;
+        onOpenChange?: (isOpen: boolean) => void;
+        placement?: string;
+        offset?: number;
+    };
+    /** Custom listbox props */
+    listboxProps?: ComponentPropsWithoutRef<"ul"> & {
+        emptyContent?: ReactNode;
+    };
+    /** Custom input props */
+    inputProps?: ComponentPropsWithoutRef<"input">;
+    /** Custom scroll shadow props */
+    scrollShadowProps?: ComponentPropsWithoutRef<"div"> & {
+        hideScrollBar?: boolean;
+    };
+    /** Custom selector button props */
+    selectorButtonProps?: ComponentPropsWithoutRef<"button">;
+    /** Custom clear button props */
+    clearButtonProps?: ComponentPropsWithoutRef<"button">;
+    /** Event Handlers */
+    onOpenChange?: (isOpen: boolean, menuTrigger?: MenuTriggerAction) => void;
+    onInputChange?: (value: string) => void;
+    onSelectionChange?: (key: Key) => void;
+    onFocus?: (e: FocusEvent_2<HTMLInputElement>) => void;
+    onBlur?: (e: FocusEvent_2<HTMLInputElement>) => void;
+    onFocusChange?: (isFocused: boolean) => void;
+    onKeyDown?: (e: KeyboardEvent_2) => void;
+    onKeyUp?: (e: KeyboardEvent_2) => void;
+    onClose?: () => void;
+    onClear?: () => void;
+}
+
+/**
+ * AutocompleteSection component for grouping items in the autocomplete dropdown
+ */
+export declare const AutocompleteSection: ForwardRefExoticComponent<AutocompleteSectionProps & {
+/** Whether to show divider after this section */
+showDivider?: boolean;
+} & RefAttributes<HTMLDivElement>>;
+
+/**
+ * AutocompleteSection component props
+ */
+export declare interface AutocompleteSectionProps extends Omit<ComponentPropsWithoutRef<"div">, "title"> {
+    /** Section title */
+    title?: ReactNode;
+    /** Show divider */
+    showDivider?: boolean;
+    /** Custom class names for slots */
+    classNames?: Partial<Record<keyof AutocompleteSectionSlots, string>>;
+}
+
+/**
+ * AutocompleteSection slots
+ */
+declare interface AutocompleteSectionSlots {
+    /** Base wrapper for the section */
+    base: string;
+    /** Section heading */
+    heading: string;
+    /** Group of items */
+    group: string;
+    /** Divider */
+    divider: string;
+}
+
+/**
+ * Autocomplete size variants
+ */
+declare type AutocompleteSize = 'sm' | 'md' | 'lg';
+
+/**
+ * Autocomplete slots for styling customization
+ */
+declare interface AutocompleteSlots {
+    /** Main wrapper around input and popover */
+    base: string;
+    /** Input wrapper around the input field */
+    inputWrapper: string;
+    /** Wrapper around the listbox content */
+    listboxWrapper: string;
+    /** Popover content container */
+    popoverContent: string;
+    /** Wrapper for end content (clear + selector buttons) */
+    endContentWrapper: string;
+    /** Clear button styling */
+    clearButton: string;
+    /** Selector button styling */
+    selectorButton: string;
+}
+
+/**
+ * Autocomplete variant styles
+ */
+declare type AutocompleteVariant = 'flat' | 'bordered' | 'faded' | 'underlined';
+
+/**
+ * Avatar component following HeroUI design system
+ * Displays user profile picture, initials, or fallback icon
+ */
+export declare const Avatar: default_2.ForwardRefExoticComponent<AvatarProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Avatar color variants following HeroUI design system
+ */
+export declare type AvatarColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+
+/**
+ * AvatarGroup component following HeroUI design system
+ * Groups multiple avatars with overflow handling and consistent styling
+ */
+export declare const AvatarGroup: default_2.ForwardRefExoticComponent<AvatarGroupProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Avatar Group context value
+ */
+declare interface AvatarGroupContextValue {
+    /** Size applied to all avatars in the group */
+    size?: AvatarSize;
+    /** Color applied to all avatars in the group */
+    color?: AvatarColor;
+    /** Radius applied to all avatars in the group */
+    radius?: AvatarRadius;
+    /** Whether all avatars in the group are disabled */
+    isDisabled?: boolean;
+    /** Whether all avatars in the group should have borders */
+    isBordered?: boolean;
+    /** Maximum number of avatars to display */
+    max?: number;
+    /** Total number of avatars */
+    total?: number;
+    /** Whether to display avatars in a grid layout */
+    isGrid?: boolean;
+    /** Custom function to render the count indicator */
+    renderCount?: (count: number) => ReactNode;
+}
+
+/**
+ * Avatar Group component props
+ */
+export declare interface AvatarGroupProps extends Omit<ComponentPropsWithoutRef<"div">, "color"> {
+    /** Maximum number of avatars to display */
+    max?: number;
+    /** Total number of avatars (for count display) */
+    total?: number;
+    /** Size applied to all avatars in the group */
+    size?: AvatarSize;
+    /** Color applied to all avatars in the group */
+    color?: AvatarColor;
+    /** Radius applied to all avatars in the group */
+    radius?: AvatarRadius;
+    /** Whether to display avatars in a grid layout */
+    isGrid?: boolean;
+    /** Whether all avatars in the group are disabled */
+    isDisabled?: boolean;
+    /** Whether all avatars in the group should have borders */
+    isBordered?: boolean;
+    /** Custom function to render the count indicator */
+    renderCount?: (count: number) => ReactNode;
+    /** Custom class names for avatar group slots */
+    classNames?: Partial<Record<keyof AvatarGroupSlots, string>>;
+    /** Data test id for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Avatar Group slots for styling customization
+ */
+declare interface AvatarGroupSlots {
+    /** Base wrapper for the avatar group */
+    base: string;
+    /** Count indicator showing additional avatars */
+    count: string;
+}
+
+/**
+ * Default Avatar Icon component
+ * Used as fallback when no image or name is provided
+ */
+export declare const AvatarIcon: default_2.FC<AvatarIconProps>;
+
+/**
+ * Default Avatar Icon component props
+ */
+export declare interface AvatarIconProps extends ComponentPropsWithoutRef<"svg"> {
+    /** Size of the icon */
+    size?: number;
+    /** Custom class name */
+    className?: string;
+}
+
+/**
+ * Base Avatar component props
+ */
+export declare interface AvatarProps extends Omit<ComponentPropsWithoutRef<"div">, "color"> {
+    /** Image source URL for the avatar */
+    src?: string;
+    /** Color theme of the avatar */
+    color?: AvatarColor;
+    /** Border radius of the avatar */
+    radius?: AvatarRadius;
+    /** Size of the avatar */
+    size?: AvatarSize;
+    /** Name for generating initials and accessible background color */
+    name?: string;
+    /** Custom icon to display as fallback */
+    icon?: ReactNode;
+    /** Custom fallback component when image fails to load */
+    fallback?: ReactNode;
+    /** Whether the avatar should have a border */
+    isBordered?: boolean;
+    /** Whether the avatar is disabled */
+    isDisabled?: boolean;
+    /** Whether the avatar can receive focus */
+    isFocusable?: boolean;
+    /** Whether to show fallback when image fails to load */
+    showFallback?: boolean;
+    /** Custom component to use for the image element */
+    ImgComponent?: ElementType;
+    /** Props to pass to the image component */
+    imgProps?: ComponentPropsWithoutRef<"img">;
+    /** Custom function to generate initials from name */
+    getInitials?: GetInitialsFunction;
+    /** Custom class names for avatar slots */
+    classNames?: Partial<Record<keyof AvatarSlots, string>>;
+    /** Component to render as (default: "div") */
+    as?: ElementType;
+    /** Data test id for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Avatar props interface (based on common avatar patterns)
+ */
+declare interface AvatarProps_2 {
+    /** Source URL for the avatar image */
+    src?: string;
+    /** Alt text for accessibility */
+    alt?: string;
+    /** Name to display when image is not available (shows initials) */
+    name?: string;
+    /** Size variant of the avatar */
+    size?: "sm" | "md" | "lg";
+    /** Custom CSS classes */
+    className?: string;
+    /** Whether the avatar should be squared */
+    isSquared?: boolean;
+    /** Color variant */
+    color?: "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+    /** Whether the avatar is disabled */
+    isDisabled?: boolean;
+    /** Custom fallback element */
+    fallback?: ReactNode;
+}
+
+/**
+ * Avatar radius variants
+ */
+export declare type AvatarRadius = 'none' | 'sm' | 'md' | 'lg' | 'full';
+
+/**
+ * Avatar size variants
+ */
+export declare type AvatarSize = 'sm' | 'md' | 'lg';
+
+/**
+ * Avatar slots for styling customization
+ */
+declare interface AvatarSlots {
+    /** Avatar wrapper, includes styles for focus ring, position, and general appearance */
+    base: string;
+    /** Image element within the avatar, includes styles for opacity transition and size */
+    img: string;
+    /** Fallback content when the image fails to load or is not provided */
+    fallback: string;
+    /** Initials displayed when image is not provided or fails to load */
+    name: string;
+    /** Icon element within the avatar, includes styles for centering and size */
+    icon: string;
+}
+
+/**
+ * Badge component following HeroUI design system
+ * A badge is a small component that represents a status or notification
+ */
+export declare const Badge: ForwardRefExoticComponent<BadgeProps & RefAttributes<HTMLDivElement>>;
+
+export declare type BadgeColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+export declare type BadgePlacement = "top-right" | "top-left" | "bottom-right" | "bottom-left";
+
+export declare interface BadgeProps {
+    /**
+     * The children to wrap with the badge
+     */
+    children?: ReactNode;
+    /**
+     * The content to display in the badge
+     */
+    content?: ReactNode;
+    /**
+     * The variant of the badge
+     * @default "solid"
+     */
+    variant?: BadgeVariant;
+    /**
+     * The color of the badge
+     * @default "default"
+     */
+    color?: BadgeColor;
+    /**
+     * The size of the badge
+     * @default "md"
+     */
+    size?: BadgeSize;
+    /**
+     * The shape of the badge
+     * @default "rectangle"
+     */
+    shape?: BadgeShape;
+    /**
+     * The placement of the badge relative to its children
+     * @default "top-right"
+     */
+    placement?: BadgePlacement;
+    /**
+     * Whether the badge is visible
+     * @default true
+     */
+    isOneChar?: boolean;
+    /**
+     * Whether to show an outline around the badge
+     * @default false
+     */
+    showOutline?: boolean;
+    /**
+     * Whether the badge should be invisible
+     * @default false
+     */
+    isInvisible?: boolean;
+    /**
+     * Whether to disable the scale animation
+     * @default false
+     */
+    disableAnimation?: boolean;
+    /**
+     * Custom class names for different slots
+     */
+    classNames?: BadgeSlots;
+    /**
+     * Custom class name for the base element
+     */
+    className?: string;
+}
+
+export declare type BadgeShape = "circle" | "rectangle";
+
+export declare type BadgeSize = "sm" | "md" | "lg";
+
+declare interface BadgeSlots {
+    /**
+     * Container element that wraps the content and badge
+     */
+    base?: string;
+    /**
+     * Badge element that displays the badge content
+     */
+    badge?: string;
+}
+
+export declare type BadgeVariant = "solid" | "flat" | "faded" | "shadow";
+
+export declare interface BaseAnimatedContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    trigger?: TriggerType;
+    delay?: number;
+    duration?: number;
+    easing?: EasingType;
+    disabled?: boolean;
+    variants?: Variants;
+    transition?: Transition;
+    className?: string;
+    style?: React.CSSProperties;
+    onAnimationStart?: () => void;
+    onAnimationComplete?: () => void;
+}
+
+export declare interface BaseAnimationProps {
+    children: ReactNode;
+    className?: string;
+    delay?: number;
+    duration?: number;
+    disabled?: boolean;
+    trigger?: 'hover' | 'tap' | 'inView' | 'manual';
+    once?: boolean;
+    threshold?: number;
+    style?: React.CSSProperties;
+}
+
+declare interface BaseSpinnerProps extends Omit<HTMLMotionProps<'div'>, 'children'> {
+    /** Type of spinner animation */
+    type?: SpinnerType;
+    /** Size of the spinner */
+    size?: SpinnerSize;
+    /** Color theme of the spinner */
+    color?: SpinnerColor;
+    /** Animation speed */
+    speed?: SpinnerSpeed;
+    /** Whether the spinner is visible */
+    visible?: boolean;
+    /** Custom animation configuration */
+    animationConfig?: Partial<SpinnerAnimationConfig>;
+    /** Additional CSS classes */
+    className?: string;
+    /** ARIA label for accessibility */
+    'aria-label'?: string;
+    /** Test ID for testing */
+    'data-testid'?: string;
+}
+
+/**
+ * Base props shared by all text animation components
+ */
+export declare interface BaseTextProps {
+    /** Text content to animate */
+    text: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Animation trigger type */
+    trigger?: TextTrigger;
+    /** Whether to repeat the animation */
+    repeat?: boolean;
+    /** Delay before animation starts (in seconds) */
+    delay?: number;
+    /** Whether animation is disabled */
+    disabled?: boolean;
+    /** Manual trigger control when trigger is 'manual' */
+    isActive?: boolean;
+    /** Callback when animation completes */
+    onComplete?: () => void;
+    /** Callback when animation starts */
+    onStart?: () => void;
+    /** Test ID for testing */
+    'data-testid'?: string;
+}
+
+/**
+ * Base tooltip props
+ */
+declare interface BaseTooltipProps {
+    /** Tooltip content */
+    content: ReactNode;
+    /** Placement of tooltip */
+    placement?: TooltipPlacement;
+    /** How tooltip is triggered */
+    trigger?: TooltipTrigger;
+    /** Size variant */
+    size?: TooltipSize;
+    /** Color variant */
+    variant?: TooltipVariant;
+    /** Animation type */
+    animation?: TooltipAnimation;
+    /** Advanced animation configuration */
+    animationConfig?: TooltipAnimationConfig;
+    /** Custom offset */
+    offset?: TooltipOffset;
+    /** Arrow configuration */
+    arrow?: TooltipArrow;
+    /** Show/hide delays */
+    delay?: TooltipDelay;
+    /** Whether tooltip is disabled */
+    disabled?: boolean;
+    /** Whether tooltip is open (for manual trigger) */
+    open?: boolean;
+    /** Default open state (for uncontrolled) */
+    defaultOpen?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Custom z-index */
+    zIndex?: number;
+    /** Whether to render in portal */
+    portal?: boolean;
+    /** Portal container */
+    portalContainer?: Element | DocumentFragment;
+    /** Custom CSS classes */
+    className?: string;
+    /** Custom styles */
+    style?: React.CSSProperties;
+    /** ARIA label for accessibility */
+    'aria-label'?: string;
+    /** ARIA described by for accessibility */
+    'aria-describedby'?: string;
+    /** Custom ID */
+    id?: string;
+}
+
+/**
+ * Bounce Animation Component
+ *
+ * Creates a bouncing animation effect with customizable amplitude and frequency
+ */
+export declare const Bounce: React.FC<BounceProps>;
+
+export declare const BounceContainer: default_2.FC<BounceContainerProps>;
+
+export declare interface BounceContainerProps extends BaseAnimatedContainerProps {
+    intensity?: AnimationIntensity;
+    bounceCount?: number;
+    startScale?: number;
+}
+
+export declare interface BounceProps extends BaseAnimationProps {
+    amplitude?: number;
+    frequency?: number;
+    damping?: number;
+}
+
+export declare const Breadcrumb: default_2.ForwardRefExoticComponent<BreadcrumbProps & default_2.RefAttributes<HTMLElement>>;
+
+declare type BreadcrumbColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+
+export declare const BreadcrumbItem: default_2.ForwardRefExoticComponent<BreadcrumbItemProps & default_2.RefAttributes<HTMLAnchorElement>>;
+
+export declare interface BreadcrumbItemProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'color'> {
+    children: ReactNode;
+    href?: string;
+    to?: string;
+    isDisabled?: boolean;
+    isCurrent?: boolean;
+    startContent?: ReactNode;
+    endContent?: ReactNode;
+    className?: string;
+    itemClassName?: string;
+    linkClassName?: string;
+    size?: BreadcrumbSize;
+    color?: BreadcrumbColor;
+    variant?: BreadcrumbVariant;
+    onPress?: (event: default_2.MouseEvent<HTMLAnchorElement>) => void;
+}
+
+export declare interface BreadcrumbProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    children: ReactNode;
+    size?: BreadcrumbSize;
+    color?: BreadcrumbColor;
+    variant?: BreadcrumbVariant;
+    separator?: SeparatorType | ReactNode;
+    separatorClassName?: string;
+    itemsClassName?: string;
+    hideSeparator?: boolean;
+    maxItems?: number;
+    showRoot?: boolean;
+    isDisabled?: boolean;
+    itemsBeforeCollapse?: number;
+    itemsAfterCollapse?: number;
+    renderEllipsis?: (hiddenItems: number) => ReactNode;
+    className?: string;
+    listProps?: HTMLAttributes<HTMLOListElement>;
+}
+
+export declare const BreadcrumbSeparator: default_2.ForwardRefExoticComponent<BreadcrumbSeparatorProps & default_2.RefAttributes<HTMLSpanElement>>;
+
+export declare interface BreadcrumbSeparatorProps {
+    type?: SeparatorType;
+    customIcon?: ReactNode;
+    className?: string;
+    size?: BreadcrumbSize;
+    color?: BreadcrumbColor;
+}
+
+declare type BreadcrumbSize = 'sm' | 'md' | 'lg';
+
+declare type BreadcrumbVariant = 'solid' | 'bordered' | 'light' | 'flat';
+
+/**
+ * Enhanced Button component with Framer Motion animations
+ * Supports multiple variants, colors, sizes, and interactive states
+ * @param props - Button component properties
+ * @returns JSX element representing a styled button
+ */
+export declare const Button: ({ children, className, ariaLabel, color, disabled, isLoading, onClick, type, size, variant, radius, startIcon, endIcon, fullWidth, disableAnimation, hoverAnimation, clickAnimation, "data-testid": dataTestId, }: ButtonProps) => JSX.Element;
+
+/**
+ * Click animation variants for Button component
+ */
+export declare type ButtonClickAnimation = "none" | "scale" | "bounce" | "ripple" | "press" | "punch" | "wiggle";
+
+/**
+ * Color variants for Button component
+ */
+export declare type ButtonColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * ButtonContent component for button text content
+ * @param props - ButtonContent component properties
+ * @returns JSX element representing button content
+ */
+export declare const ButtonContent: ({ children, className, "data-testid": dataTestId, }: ButtonContentProps) => JSX.Element;
+
+/**
+ * Props interface for ButtonContent component
+ */
+export declare interface ButtonContentProps {
+    /** Content to render inside the button content */
+    children: ReactNode;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * ButtonGroup component for grouping multiple buttons
+ * @param props - ButtonGroup component properties
+ * @returns JSX element representing a group of buttons
+ */
+export declare const ButtonGroup: ({ children, className, size, color, variant, radius, isAttached, disabled, disableAnimation, "data-testid": dataTestId, }: ButtonGroupProps) => JSX.Element;
+
+/**
+ * Props interface for ButtonGroup component
+ */
+export declare interface ButtonGroupProps {
+    /** Button components to render inside the group */
+    children: ReactNode;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Size variant for all buttons in group */
+    size?: ButtonSize;
+    /** Color theme for all buttons in group */
+    color?: ButtonColor;
+    /** Visual style variant for all buttons in group */
+    variant?: ButtonVariant;
+    /** Border radius for all buttons in group */
+    radius?: ButtonRadius;
+    /** Whether buttons are attached (no spacing) */
+    isAttached?: boolean;
+    /** Whether the group is disabled */
+    disabled?: boolean;
+    /** Whether to disable hover and focus animations for all buttons */
+    disableAnimation?: boolean;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Hover animation variants for Button component
+ */
+export declare type ButtonHoverAnimation = "none" | "scale" | "lift" | "bounce" | "pulse" | "shake" | "rotate" | "glow";
+
+/**
+ * ButtonIcon component for button icons
+ * @param props - ButtonIcon component properties
+ * @returns JSX element representing button icon
+ */
+export declare const ButtonIcon: ({ children, className, position, "data-testid": dataTestId, }: ButtonIconProps) => JSX.Element;
+
+/**
+ * Props interface for ButtonIcon component
+ */
+export declare interface ButtonIconProps {
+    /** Icon element to render */
+    children: ReactNode;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Position of the icon */
+    position?: "start" | "end";
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Props interface for the main Button component
+ */
+export declare interface ButtonProps {
+    /** Content to render inside the button */
+    children: ReactNode;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Accessibility label for screen readers */
+    ariaLabel?: string;
+    /** Color theme of the button */
+    color?: ButtonColor;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Whether the button is in loading state */
+    isLoading?: boolean;
+    /** Click handler function */
+    onClick?: () => void;
+    /** HTML button type attribute */
+    type?: "button" | "submit" | "reset";
+    /** Size variant of the button */
+    size?: ButtonSize;
+    /** Visual style variant */
+    variant?: ButtonVariant;
+    /** Border radius of the button */
+    radius?: ButtonRadius;
+    /** Icon to display before text */
+    startIcon?: ReactNode;
+    /** Icon to display after text */
+    endIcon?: ReactNode;
+    /** Whether to show full width */
+    fullWidth?: boolean;
+    /** Whether to disable hover and focus animations */
+    disableAnimation?: boolean;
+    /** Hover animation type - Framer Motion powered */
+    hoverAnimation?: ButtonHoverAnimation;
+    /** Click animation type - Framer Motion powered */
+    clickAnimation?: ButtonClickAnimation;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Radius variants for Button component
+ */
+export declare type ButtonRadius = "none" | "sm" | "md" | "lg" | "xl" | "full";
+
+/**
+ * Size variants for Button component
+ */
+export declare type ButtonSize = "xs" | "sm" | "md" | "lg" | "xl";
+
+/**
+ * ButtonText component for button text
+ * @param props - ButtonText component properties
+ * @returns JSX element representing button text
+ */
+export declare const ButtonText: ({ children, className, "data-testid": dataTestId, }: ButtonTextProps) => JSX.Element;
+
+/**
+ * Props interface for ButtonText component
+ */
+export declare interface ButtonTextProps {
+    /** Text content to render */
+    children: ReactNode;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Visual variants for Button component
+ */
+export declare type ButtonVariant = "solid" | "outline" | "ghost" | "link" | "gradient" | "faded" | "light" | "bordered" | "outlined";
+
+/**
+ * Reusable Card component with multiple variants, colors, and sizes
+ * Supports accessibility features and consistent styling across the application
+ * @param props - Card component properties
+ * @returns JSX element representing a styled card
+ */
+export declare const Card: ({ children, className, size, variant, color, radius, isClickable, isDisabled, isHoverable, onClick, "data-testid": dataTestId, }: CardProps) => JSX.Element;
+
+/**
+ * Color variants for Card component
+ */
+declare type CardColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * Props interface for the main Card component
+ */
+export declare interface CardProps {
+    /** Content to render inside the card */
+    children: ReactNode;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Size variant of the card */
+    size?: CardSize;
+    /** Visual style variant */
+    variant?: CardVariant;
+    /** Color theme of the card */
+    color?: CardColor;
+    /** Border radius of the card */
+    radius?: CardRadius;
+    /** Whether the card is clickable */
+    isClickable?: boolean;
+    /** Whether the card is disabled */
+    isDisabled?: boolean;
+    /** Whether the card is hoverable */
+    isHoverable?: boolean;
+    /** Click handler function */
+    onClick?: () => void;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Radius variants for Card component
+ */
+declare type CardRadius = "none" | "sm" | "md" | "lg" | "xl" | "full";
+
+/**
+ * Size variants for Card component
+ */
+declare type CardSize = "sm" | "md" | "lg" | "xl";
+
+/**
+ * Visual variants for Card component
+ */
+declare type CardVariant = "elevated" | "bordered" | "shadow" | "flat";
+
+/**
+ * Enhanced Checkbox component with comprehensive features
+ * Supports multiple sizes, colors, states, and custom icons
+ * @param props - Checkbox component properties
+ * @returns JSX element representing a styled checkbox
+ */
+export declare const Checkbox: ({ children, icon: IconComponent, value, name, size, color, radius, lineThrough, isSelected: controlledSelected, defaultSelected, isRequired, isReadOnly, isDisabled, isIndeterminate, isInvalid, validationState, disableAnimation, className, classNames, onChange, onValueChange, "data-testid": dataTestId, }: CheckboxProps) => JSX.Element;
+
+/**
+ * Color variants for Checkbox component
+ */
+declare type CheckboxColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * Props interface for custom checkbox icon
+ */
+declare interface CheckboxIconProps {
+    /** Whether the checkbox is selected */
+    isSelected?: boolean;
+    /** Whether the checkbox is indeterminate */
+    isIndeterminate?: boolean;
+    /** Whether animations are disabled */
+    disableAnimation?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+/**
+ * Props interface for the main Checkbox component
+ */
+export declare interface CheckboxProps {
+    /** Content to render as checkbox label */
+    children?: ReactNode;
+    /** Custom icon component for checkbox */
+    icon?: React.ComponentType<CheckboxIconProps>;
+    /** Value attribute for the checkbox input */
+    value?: string;
+    /** Name attribute for the checkbox input */
+    name?: string;
+    /** Size variant of the checkbox */
+    size?: CheckboxSize;
+    /** Color theme of the checkbox */
+    color?: CheckboxColor;
+    /** Border radius of the checkbox */
+    radius?: CheckboxRadius;
+    /** Whether to show line-through effect on label when checked */
+    lineThrough?: boolean;
+    /** Whether the checkbox is selected (controlled) */
+    isSelected?: boolean;
+    /** Default selected state (uncontrolled) */
+    defaultSelected?: boolean;
+    /** Whether the checkbox is required */
+    isRequired?: boolean;
+    /** Whether the checkbox is read-only */
+    isReadOnly?: boolean;
+    /** Whether the checkbox is disabled */
+    isDisabled?: boolean;
+    /** Whether the checkbox is in indeterminate state */
+    isIndeterminate?: boolean;
+    /** Whether the checkbox is invalid */
+    isInvalid?: boolean;
+    /** Validation state of the checkbox */
+    validationState?: CheckboxValidationState;
+    /** Whether to disable hover and focus animations */
+    disableAnimation?: boolean;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Custom class names for different slots */
+    classNames?: Partial<Record<"base" | "wrapper" | "icon" | "label" | "hiddenInput", string>>;
+    /** Native change event handler */
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+    /** Value change event handler */
+    onValueChange?: (isSelected: boolean) => void;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Radius variants for Checkbox component
+ */
+declare type CheckboxRadius = "none" | "sm" | "md" | "lg" | "full";
+
+/**
+ * Size variants for Checkbox component
+ */
+declare type CheckboxSize = "sm" | "md" | "lg";
+
+/**
+ * Validation state for Checkbox component
+ */
+declare type CheckboxValidationState = "valid" | "invalid";
+
+/**
+ * Chip component following HeroUI design system
+ * A small block of essential information that represents an input, attribute, or action
+ */
+export declare const Chip: ForwardRefExoticComponent<ChipProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ChipColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+export declare interface ChipProps {
+    /**
+     * The content to display inside the chip
+     */
+    children?: ReactNode;
+    /**
+     * The variant of the chip
+     * @default "solid"
+     */
+    variant?: ChipVariant;
+    /**
+     * The color of the chip
+     * @default "default"
+     */
+    color?: ChipColor;
+    /**
+     * The size of the chip
+     * @default "md"
+     */
+    size?: ChipSize;
+    /**
+     * The radius of the chip
+     * @default "full"
+     */
+    radius?: ChipRadius;
+    /**
+     * Avatar element to display on the left side
+     */
+    avatar?: ReactNode;
+    /**
+     * Content to display at the start of the chip
+     */
+    startContent?: ReactNode;
+    /**
+     * Content to display at the end of the chip
+     */
+    endContent?: ReactNode;
+    /**
+     * Whether the chip is disabled
+     * @default false
+     */
+    isDisabled?: boolean;
+    /**
+     * Custom class names for different slots
+     */
+    classNames?: ChipSlots;
+    /**
+     * Custom class name for the chip
+     */
+    className?: string;
+    /**
+     * Handler called when the close button is clicked
+     */
+    onClose?: (e: MouseEvent_2<HTMLButtonElement>) => void;
+}
+
+declare type ChipRadius = "none" | "sm" | "md" | "lg" | "full";
+
+export declare type ChipSize = "sm" | "md" | "lg";
+
+declare interface ChipSlots {
+    /**
+     * The base slot of the chip, it is the container of the chip
+     */
+    base?: string;
+    /**
+     * The content slot of the chip, it is the container of the chip children
+     */
+    content?: string;
+    /**
+     * Small dot on the left side of the chip. Visible when variant=dot
+     */
+    dot?: string;
+    /**
+     * Avatar classes of the chip. Visible when avatar prop is passed
+     */
+    avatar?: string;
+    /**
+     * Close button classes of the chip. Visible when onClose prop is passed
+     */
+    closeButton?: string;
+}
+
+export declare type ChipVariant = "solid" | "bordered" | "light" | "flat" | "faded" | "shadow" | "dot";
+
+/**
+ * Column alignment options
+ */
+declare type ColumnAlign = "start" | "center" | "end";
+
+/**
+ * Column definition interface
+ */
+declare interface ColumnDef<T = any> {
+    key: Key;
+    label: ReactNode;
+    align?: ColumnAlign;
+    allowsSorting?: boolean;
+    hideHeader?: boolean;
+    isRowHeader?: boolean;
+    sortIcon?: ReactNode;
+    width?: string | number;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    render?: (item: T) => ReactNode;
+}
+
+/**
+ * Content placement options
+ */
+declare type ContentPlacement = "inside" | "outside";
+
+/**
+ * CounterText Component
+ *
+ * Animates a number from one value to another with formatting options
+ * and customizable animation effects.
+ *
+ * @example
+ * <CounterText
+ *   from={0}
+ *   to={1000}
+ *   duration={2}
+ *   format="currency"
+ *   currency="USD"
+ *   decimals={2}
+ * />
+ */
+export declare const CounterText: React_2.FC<CounterTextProps>;
+
+/**
+ * CounterText component props
+ */
+export declare interface CounterTextProps extends Omit<BaseTextProps, 'text'> {
+    /** Starting number */
+    from: number;
+    /** Ending number */
+    to: number;
+    /** Animation duration in seconds */
+    duration?: number;
+    /** Number of decimal places */
+    decimals?: number;
+    /** Number format (e.g., currency, percentage) */
+    format?: 'number' | 'currency' | 'percentage';
+    /** Currency symbol for currency format */
+    currency?: string;
+    /** Locale for number formatting */
+    locale?: string;
+    /** Custom formatter function */
+    formatter?: (value: number) => string;
+    /** Animation easing */
+    easing?: TextEasing;
+    /** Prefix text */
+    prefix?: string;
+    /** Suffix text */
+    suffix?: string;
+}
+
+/**
+ * Typewriter cursor styles
+ */
+export declare type CursorStyle = 'block' | 'line' | 'underscore' | 'none';
+
+/**
+ * Disabled behavior types
+ */
+declare type DisabledBehavior = "selection" | "all";
+
+declare type EasingType = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | 'backIn' | 'backOut' | 'backInOut' | 'bounceIn' | 'bounceOut' | 'bounceInOut' | 'elasticIn' | 'elasticOut' | 'elasticInOut';
+
+declare type EasingType_2 = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | 'circIn' | 'circOut' | 'circInOut' | 'backIn' | 'backOut' | 'backInOut' | 'anticipate';
+
+export declare interface EffectConfig {
+    shadow?: boolean;
+    shadowColor?: string;
+    shadowBlur?: number;
+    glow?: boolean;
+    glowColor?: string;
+    glowIntensity?: number;
+}
+
+export declare const FadeContainer: default_2.FC<FadeContainerProps>;
+
+export declare interface FadeContainerProps extends BaseAnimatedContainerProps {
+    startOpacity?: number;
+    endOpacity?: number;
+    blur?: boolean;
+    blurAmount?: number;
+}
+
+/**
+ * FadeIn Animation Component
+ *
+ * Animates opacity from transparent to opaque with customizable timing and triggers
+ */
+export declare const FadeIn: React.FC<FadeInProps>;
+
+export declare interface FadeInProps extends BaseAnimationProps {
+    from?: number;
+    to?: number;
+}
+
+/**
+ * Filter function type
+ */
+declare type FilterFunction = (textValue: string, inputValue: string) => boolean;
+
+export declare const FlipContainer: default_2.FC<FlipContainerProps>;
+
+export declare interface FlipContainerProps extends BaseAnimatedContainerProps {
+    direction?: FlipDirection;
+    perspective?: number;
+    backfaceVisible?: boolean;
+}
+
+declare type FlipDirection = 'horizontal' | 'vertical' | 'both';
+
+/**
+ * Function to generate custom initials from name
+ */
+declare type GetInitialsFunction = (name: string) => string;
+
+/**
+ * Glitch intensity levels
+ */
+export declare type GlitchIntensity = 'low' | 'medium' | 'high' | 'extreme';
+
+/**
+ * GlitchText Component
+ *
+ * Creates a glitch effect on text with customizable intensity levels,
+ * colors, and corruption effects. Supports continuous animation and
+ * various trigger modes.
+ *
+ * @example
+ * <GlitchText
+ *   text="GLITCH EFFECT"
+ *   intensity="high"
+ *   continuous={true}
+ *   colors={['#ff0000', '#00ff00', '#0000ff']}
+ *   corruptData={true}
+ * />
+ */
+export declare const GlitchText: React_2.FC<GlitchTextProps>;
+
+/**
+ * GlitchText component props
+ */
+export declare interface GlitchTextProps extends BaseTextProps {
+    /** Glitch effect intensity */
+    intensity?: GlitchIntensity;
+    /** Animation duration in seconds */
+    duration?: number;
+    /** Whether to animate continuously */
+    continuous?: boolean;
+    /** Glitch colors array */
+    colors?: string[];
+    /** Whether to include data corruption effect */
+    corruptData?: boolean;
+    /** Custom glitch characters */
+    glitchChars?: string;
+    /** Number of glitch layers */
+    layers?: number;
+}
+
+/**
+ * Gradient animation directions
+ */
+export declare type GradientDirection = 'horizontal' | 'vertical' | 'diagonal' | 'radial';
+
+/**
+ * GradientText Component
+ *
+ * Displays text with animated color gradients that can move in different directions.
+ * Supports continuous animation and various gradient styles.
+ *
+ * @example
+ * <GradientText
+ *   text="Texto con gradiente animado"
+ *   colors={['#ff0000', '#00ff00', '#0000ff']}
+ *   direction="horizontal"
+ *   animate={true}
+ *   duration={3}
+ * />
+ */
+export declare const GradientText: React_2.FC<GradientTextProps>;
+
+/**
+ * GradientText component props
+ */
+export declare interface GradientTextProps extends BaseTextProps {
+    /** Gradient colors array */
+    colors: string[];
+    /** Gradient animation direction */
+    direction?: GradientDirection;
+    /** Animation duration in seconds */
+    duration?: number;
+    /** Animation speed multiplier */
+    speed?: number;
+    /** Whether to animate continuously */
+    animate?: boolean;
+    /** Background size for gradient animation */
+    backgroundSize?: string;
+    /** Custom gradient stops */
+    stops?: number[];
+}
+
+/**
+ * Enhanced Image component with comprehensive features
+ * Supports lazy loading, fallback images, zoom effects, and blur effects
+ * @param props - Image component properties
+ * @returns JSX element representing a styled image
+ */
+declare const Image_2: ({ src, srcSet, sizes, alt, width, height, radius, shadow, loading, fallbackSrc, isBlurred, isZoomed, removeWrapper, disableSkeleton, className, classNames, onLoad, onError, "data-testid": dataTestId, }: ImageProps) => JSX.Element;
+export { Image_2 as Image }
+
+/**
+ * Loading behavior for Image component
+ */
+export declare type ImageLoading = "eager" | "lazy";
+
+/**
+ * Props interface for the main Image component
+ */
+export declare interface ImageProps {
+    /** Image source URL */
+    src: string;
+    /** Image source set for responsive images */
+    srcSet?: string;
+    /** Image sizes attribute for responsive images */
+    sizes?: string;
+    /** Alternative text for the image */
+    alt: string;
+    /** Image width */
+    width?: number;
+    /** Image height */
+    height?: number;
+    /** Border radius variant */
+    radius?: ImageRadius;
+    /** Shadow variant */
+    shadow?: ImageShadow;
+    /** Loading behavior */
+    loading?: ImageLoading;
+    /** Fallback image source URL when main image fails to load */
+    fallbackSrc?: string;
+    /** Whether to apply blur effect */
+    isBlurred?: boolean;
+    /** Whether to enable zoom on hover */
+    isZoomed?: boolean;
+    /** Whether to remove the wrapper div */
+    removeWrapper?: boolean;
+    /** Whether to disable skeleton loading animation */
+    disableSkeleton?: boolean;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Custom class names for different slots */
+    classNames?: Partial<Record<"img" | "wrapper" | "zoomedWrapper" | "blurredImg", string>>;
+    /** Image load event handler */
+    onLoad?: ReactEventHandler<HTMLImageElement>;
+    /** Image error event handler */
+    onError?: () => void;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Radius variants for Image component
+ */
+export declare type ImageRadius = "none" | "sm" | "md" | "lg" | "full";
+
+/**
+ * Shadow variants for Image component
+ */
+export declare type ImageShadow = "none" | "sm" | "md" | "lg";
+
+/**
+ * Input Component
+ *
+ * A comprehensive input component based on HeroUI design system.
+ * Supports multiple variants, sizes, colors, validation, and advanced features.
+ *
+ * Features:
+ * - Multiple variants (flat, bordered, faded, underlined)
+ * - Color themes and sizes
+ * - Label positioning (inside, outside, outside-left)
+ * - Validation with error messages
+ * - Clear button functionality
+ * - Start and end content slots
+ * - Password visibility toggle
+ * - Full accessibility support
+ *
+ * @param props - Input component props
+ * @returns JSX element representing the input
+ */
+export declare const Input: default_2.ForwardRefExoticComponent<InputProps & default_2.RefAttributes<HTMLInputElement>>;
+
+/**
+ * Input class names for different slots
+ */
+declare interface InputClassNames {
+    /** Base wrapper element */
+    base?: string;
+    /** Label element */
+    label?: string;
+    /** Main wrapper for outside label placements */
+    mainWrapper?: string;
+    /** Input wrapper element */
+    inputWrapper?: string;
+    /** Inner wrapper for input and content */
+    innerWrapper?: string;
+    /** Input element itself */
+    input?: string;
+    /** Clear button element */
+    clearButton?: string;
+    /** Helper wrapper for description and error */
+    helperWrapper?: string;
+    /** Description text element */
+    description?: string;
+    /** Error message element */
+    errorMessage?: string;
+}
+
+/**
+ * Input color variants
+ */
+declare type InputColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * Label placement options
+ */
+declare type InputLabelPlacement = "inside" | "outside" | "outside-left";
+
+/**
+ * Main Input component props interface
+ * Based on HeroUI Input component API
+ */
+export declare interface InputProps {
+    /** Input label */
+    label?: ReactNode;
+    /** Input placeholder text */
+    placeholder?: string;
+    /** Input description text */
+    description?: ReactNode;
+    /** Error message - can be static or function */
+    errorMessage?: ReactNode | ((validation: ValidationResult) => ReactNode);
+    /** Content to display at the start of the input */
+    startContent?: ReactNode;
+    /** Content to display at the end of the input */
+    endContent?: ReactNode;
+    /** Controlled input value */
+    value?: string;
+    /** Default value for uncontrolled input */
+    defaultValue?: string;
+    /** Visual variant of the input */
+    variant?: InputVariant;
+    /** Color theme */
+    color?: InputColor;
+    /** Size variant */
+    size?: InputSize;
+    /** Border radius */
+    radius?: InputRadius;
+    /** Label placement */
+    labelPlacement?: InputLabelPlacement;
+    /** Whether input takes full width */
+    fullWidth?: boolean;
+    /** Input type */
+    type?: InputType;
+    /** Minimum length validation */
+    minLength?: number;
+    /** Maximum length validation */
+    maxLength?: number;
+    /** Pattern for validation */
+    pattern?: string;
+    /** Whether the input is required */
+    isRequired?: boolean;
+    /** Whether the input is disabled */
+    isDisabled?: boolean;
+    /** Whether the input is read-only */
+    isReadOnly?: boolean;
+    /** Whether the input has validation errors */
+    isInvalid?: boolean;
+    /** Whether to show clear button */
+    isClearable?: boolean;
+    /** Whether to disable animations */
+    disableAnimation?: boolean;
+    /** Custom class names for different parts */
+    classNames?: Partial<InputClassNames>;
+    /** Additional CSS class */
+    className?: string;
+    /** Custom validation function */
+    validate?: (value: string) => ValidationError | true | null | undefined;
+    /** Validation behavior mode */
+    validationBehavior?: ValidationBehavior;
+    /** Ref to the base wrapper element */
+    baseRef?: RefObject<HTMLDivElement>;
+    /** Native change event handler */
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    /** Value change handler (HeroUI style) */
+    onValueChange?: (value: string) => void;
+    /** Clear button click handler */
+    onClear?: () => void;
+    /** Focus event handler */
+    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Blur event handler */
+    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Key down event handler */
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    /** Key up event handler */
+    onKeyUp?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    /** Test ID for automated testing */
+    "data-testid"?: string;
+    /** ARIA label */
+    "aria-label"?: string;
+    /** ARIA labelledby */
+    "aria-labelledby"?: string;
+    /** ARIA describedby */
+    "aria-describedby"?: string;
+}
+
+/**
+ * Input radius variants
+ */
+declare type InputRadius = "none" | "sm" | "md" | "lg" | "full";
+
+/**
+ * Input size variants
+ */
+declare type InputSize = "sm" | "md" | "lg";
+
+/**
+ * Input type variants
+ */
+declare type InputType = "text" | "email" | "url" | "password" | "tel" | "search" | "file" | "number";
+
+/**
+ * Input visual variants
+ */
+declare type InputVariant = "flat" | "bordered" | "faded" | "underlined";
+
+export declare const LibraryLink: default_2.FC<LibraryLinkProps>;
+
+export declare interface LibraryLinkProps {
+    to: string;
+    children: React.ReactNode;
+    className?: string;
+    activeClassName?: string;
+    exact?: boolean;
+    replace?: boolean;
+    onClick?: (event: React.MouseEvent) => void;
+}
+
+export declare interface LibraryRouterProps {
+    children: React.ReactNode;
+    basePath?: string;
+    routes?: Route[];
+    onRouteChange?: (path: string) => void;
+}
+
+/**
+ * Menu trigger behavior
+ */
+declare type MenuTriggerAction = 'focus' | 'input' | 'manual';
+
+export declare const Modal: ForwardRefExoticComponent<ModalProps & RefAttributes<HTMLDivElement>>;
+
+declare type ModalBackdrop = 'transparent' | 'opaque' | 'blur';
+
+declare type ModalPlacement = 'auto' | 'top' | 'top-center' | 'center' | 'bottom' | 'bottom-center';
+
+export declare interface ModalProps {
+    children?: ReactNode;
+    size?: ModalSize;
+    radius?: ModalRadius;
+    shadow?: ModalShadow;
+    backdrop?: ModalBackdrop;
+    scrollBehavior?: ModalScrollBehavior;
+    placement?: ModalPlacement;
+    isOpen?: boolean;
+    defaultOpen?: boolean;
+    isDismissable?: boolean;
+    isKeyboardDismissDisabled?: boolean;
+    shouldBlockScroll?: boolean;
+    hideCloseButton?: boolean;
+    closeButton?: ReactNode;
+    motionProps?: MotionProps;
+    portalContainer?: HTMLElement;
+    disableAnimation?: boolean;
+    classNames?: Partial<ModalSlots>;
+    className?: string;
+    onOpenChange?: (isOpen: boolean) => void;
+    onClose?: () => void;
+    isDraggable?: boolean;
+    allowOverflow?: boolean;
+}
+
+declare type ModalRadius = 'none' | 'sm' | 'md' | 'lg';
+
+declare type ModalScrollBehavior = 'normal' | 'inside' | 'outside';
+
+declare type ModalShadow = 'none' | 'sm' | 'md' | 'lg';
+
+declare type ModalSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | 'full';
+
+declare interface ModalSlots {
+    wrapper?: string;
+    base?: string;
+    backdrop?: string;
+    header?: string;
+    body?: string;
+    footer?: string;
+    closeButton?: string;
+}
+
+export declare const MorphingContainer: default_2.FC<MorphingContainerProps>;
+
+export declare interface MorphingContainerProps extends BaseAnimatedContainerProps {
+    morphStates?: Array<{
+        width?: string | number;
+        height?: string | number;
+        borderRadius?: string | number;
+        backgroundColor?: string;
+        transform?: string;
+    }>;
+    morphInterval?: number;
+    autoMorph?: boolean;
+}
+
+/**
+ * MorphingText Component
+ *
+ * Animates between different texts with morphing transitions.
+ * Supports multiple morph styles including fade, slide, and scramble effects.
+ *
+ * @example
+ * <MorphingText
+ *   texts={['Hola', 'Mundo', 'Texto']}
+ *   displayDuration={2000}
+ *   morphDuration={800}
+ *   morphStyle="scramble"
+ *   loop={true}
+ * />
+ */
+export declare const MorphingText: React_2.FC<MorphingTextProps>;
+
+/**
+ * MorphingText component props
+ */
+export declare interface MorphingTextProps extends Omit<BaseTextProps, 'text'> {
+    /** Array of texts to morph between */
+    texts: string[];
+    /** Duration to show each text */
+    displayDuration?: number;
+    /** Morphing animation duration */
+    morphDuration?: number;
+    /** Whether to loop through texts */
+    loop?: boolean;
+    /** Morphing animation easing */
+    easing?: TextEasing;
+    /** Character morphing style */
+    morphStyle?: 'fade' | 'slide' | 'scramble';
+}
+
+export declare const Navbar: ForwardRefExoticComponent<NavbarProps & RefAttributes<HTMLElement>>;
+
+declare type NavbarMaxWidth = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+
+declare type NavbarPosition = 'static' | 'sticky';
+
+export declare interface NavbarProps {
+    children?: ReactNode;
+    height?: string | number;
+    position?: NavbarPosition;
+    maxWidth?: NavbarMaxWidth;
+    parentRef?: React.RefObject<HTMLElement>;
+    isBordered?: boolean;
+    isBlurred?: boolean;
+    isMenuOpen?: boolean;
+    isMenuDefaultOpen?: boolean;
+    shouldHideOnScroll?: boolean;
+    disableScrollHandler?: boolean;
+    disableAnimation?: boolean;
+    classNames?: Partial<NavbarSlots>;
+    className?: string;
+    onMenuOpenChange?: (isOpen: boolean) => void;
+    onScrollPositionChange?: (position: number) => void;
+}
+
+declare interface NavbarSlots {
+    base?: string;
+    wrapper?: string;
+    brand?: string;
+    content?: string;
+    item?: string;
+    toggle?: string;
+    toggleIcon?: string;
+    menu?: string;
+    menuItem?: string;
+}
+
+export declare const Navigation: default_2.FC<NavigationProps>;
+
+export declare interface NavigationProps {
+    routes: RouteGroup[];
+    className?: string;
+    renderItem?: (route: Route, isActive: boolean) => React.ReactNode;
+}
+
+/**
+ * Main Pagination component that provides pagination functionality
+ */
+export declare const Pagination: default_2.FC<PaginationProps>;
+
+/**
+ * Color variants for Pagination component
+ */
+declare type PaginationColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * Pagination context value
+ */
+declare interface PaginationContextValue {
+    /** Current page */
+    activePage: number;
+    /** Total pages */
+    totalPages: number;
+    /** Set page function */
+    setPage: (page: number) => void;
+    /** Size variant */
+    size: PaginationSize;
+    /** Color variant */
+    color: PaginationColor;
+    /** Visual variant */
+    variant: PaginationVariant;
+    /** Border radius */
+    radius: PaginationRadius;
+    /** Whether disabled */
+    isDisabled: boolean;
+    /** Whether animations are disabled */
+    disableAnimation: boolean;
+    /** Controls configuration */
+    controls: Required<PaginationControlsConfig>;
+    /** Display configuration */
+    display: Required<PaginationDisplayConfig>;
+}
+
+/**
+ * Configuration for pagination controls
+ */
+declare interface PaginationControlsConfig {
+    /** Show previous/next buttons */
+    showControls?: boolean;
+    /** Show first/last page buttons */
+    showFirstLast?: boolean;
+    /** Placement of control buttons */
+    placement?: PaginationControlsPlacement;
+    /** Custom labels for controls */
+    labels?: {
+        prev?: string | ReactNode;
+        next?: string | ReactNode;
+        first?: string | ReactNode;
+        last?: string | ReactNode;
+    };
+}
+
+/**
+ * Placement options for pagination controls
+ */
+declare type PaginationControlsPlacement = "start" | "end" | "both";
+
+/**
+ * Props for pagination cursor (prev/next buttons)
+ */
+declare interface PaginationCursorProps {
+    /** Direction of the cursor */
+    direction: "prev" | "next";
+    /** Whether the cursor is disabled */
+    isDisabled?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Custom content to render */
+    children?: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+    /** Size variant */
+    size?: PaginationSize;
+    /** Color variant */
+    color?: PaginationColor;
+    /** Visual variant */
+    variant?: PaginationVariant;
+    /** Border radius */
+    radius?: PaginationRadius;
+    /** ARIA label for accessibility */
+    "aria-label"?: string;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Configuration for pagination display
+ */
+declare interface PaginationDisplayConfig {
+    /** Whether to show page numbers */
+    showPages?: boolean;
+    /** Maximum number of page buttons to show */
+    siblings?: number;
+    /** Show dots when pages are collapsed */
+    showDots?: boolean;
+    /** Whether to loop from last to first page */
+    loop?: boolean;
+    /** Compact mode with minimal spacing */
+    compact?: boolean;
+    /** Show shadow effect */
+    showShadow?: boolean;
+}
+
+/**
+ * Props for dots separator component
+ */
+declare interface PaginationDotsProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Size variant */
+    size?: PaginationSize;
+    /** Custom content */
+    children?: ReactNode;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Pagination ellipsis/dots component for collapsed pages
+ */
+export declare const PaginationEllipsis: ForwardRefExoticComponent<PaginationDotsProps & RefAttributes<HTMLSpanElement>>;
+
+/**
+ * First page button component
+ */
+export declare const PaginationFirst: ForwardRefExoticComponent<Omit<PaginationCursorProps, "direction"> & RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Individual pagination item component
+ */
+export declare const PaginationItem: ForwardRefExoticComponent<PaginationItemProps & RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Pagination item data structure
+ */
+declare interface PaginationItemData {
+    /** Type of the item */
+    type: PaginationItemType;
+    /** Value (page number for pages) */
+    value: number | string;
+    /** Whether the item is active */
+    isActive: boolean;
+    /** Whether the item is disabled */
+    isDisabled: boolean;
+    /** Key for React rendering */
+    key: string;
+}
+
+/**
+ * Props for individual pagination item
+ */
+export declare interface PaginationItemProps {
+    /** Page number or item identifier */
+    value: number | string;
+    /** Type of pagination item */
+    type: PaginationItemType;
+    /** Whether the item is currently active */
+    isActive?: boolean;
+    /** Whether the item is disabled */
+    isDisabled?: boolean;
+    /** Click handler for the item */
+    onClick?: (value: number | string) => void;
+    /** Custom content to render */
+    children?: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+    /** Size variant */
+    size?: PaginationSize;
+    /** Color variant */
+    color?: PaginationColor;
+    /** Visual variant */
+    variant?: PaginationVariant;
+    /** Border radius */
+    radius?: PaginationRadius;
+    /** ARIA label for accessibility */
+    "aria-label"?: string;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Item type for pagination items
+ */
+declare type PaginationItemType = "page" | "prev" | "next" | "dots" | "first" | "last";
+
+/**
+ * Last page button component
+ */
+export declare const PaginationLast: ForwardRefExoticComponent<Omit<PaginationCursorProps, "direction"> & RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Next page button component
+ */
+export declare const PaginationNext: ForwardRefExoticComponent<Omit<PaginationCursorProps, "direction"> & RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Previous page button component
+ */
+export declare const PaginationPrevious: ForwardRefExoticComponent<Omit<PaginationCursorProps, "direction"> & RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Main pagination component props
+ */
+export declare interface PaginationProps {
+    /** Total number of pages */
+    total: number;
+    /** Current active page (1-based) */
+    page?: number;
+    /** Default page for uncontrolled component */
+    defaultPage?: number;
+    /** Initial page (alias for defaultPage) */
+    initialPage?: number;
+    /** Callback when page changes */
+    onChange?: (page: number) => void;
+    /** Callback when page is clicked */
+    onPageChange?: (page: number) => void;
+    /** Size variant */
+    size?: PaginationSize;
+    /** Color variant */
+    color?: PaginationColor;
+    /** Visual variant */
+    variant?: PaginationVariant;
+    /** Border radius */
+    radius?: PaginationRadius;
+    /** Whether the pagination is disabled */
+    isDisabled?: boolean;
+    /** Whether to disable animations */
+    disableAnimation?: boolean;
+    /** Controls configuration */
+    controls?: PaginationControlsConfig;
+    /** Display configuration */
+    display?: PaginationDisplayConfig;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom styles */
+    style?: React.CSSProperties;
+    /** ARIA label for the pagination */
+    "aria-label"?: string;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+
+/**
+ * Radius variants for Pagination component
+ */
+declare type PaginationRadius = "none" | "sm" | "md" | "lg" | "xl" | "full";
+
+/**
+ * Size variants for Pagination component
+ */
+declare type PaginationSize = "xs" | "sm" | "md" | "lg" | "xl";
+
+/**
+ * Visual variants for Pagination component
+ */
+declare type PaginationVariant = "flat" | "bordered" | "light" | "faded";
+
+export declare const ParallaxContainer: default_2.FC<ParallaxContainerProps>;
+
+export declare interface ParallaxContainerProps extends BaseAnimatedContainerProps {
+    speed?: number;
+    direction?: 'vertical' | 'horizontal' | 'both';
+    offset?: number;
+    enableOnMobile?: boolean;
+}
+
+export declare const Progress: ForwardRefExoticComponent<ProgressProps & RefAttributes<HTMLDivElement>>;
+
+declare type ProgressColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+export declare interface ProgressProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /**
+     * The current progress value (0-100)
+     */
+    value?: number;
+    /**
+     * The maximum value for progress calculation
+     * @default 100
+     */
+    maxValue?: number;
+    /**
+     * The minimum value for progress calculation
+     * @default 0
+     */
+    minValue?: number;
+    /**
+     * The color theme of the progress bar
+     * @default "primary"
+     */
+    color?: ProgressColor;
+    /**
+     * The size of the progress bar
+     * @default "md"
+     */
+    size?: ProgressSize;
+    /**
+     * The radius of the progress bar
+     * @default "full"
+     */
+    radius?: ProgressRadius;
+    /**
+     * Whether to show the progress percentage as text
+     * @default false
+     */
+    showValueLabel?: boolean;
+    /**
+     * Custom label to display instead of percentage
+     */
+    label?: string;
+    /**
+     * Whether to show a striped pattern
+     * @default false
+     */
+    isStriped?: boolean;
+    /**
+     * Whether the progress is in an indeterminate state
+     * @default false
+     */
+    isIndeterminate?: boolean;
+    /**
+     * Whether to disable the progress bar
+     * @default false
+     */
+    isDisabled?: boolean;
+    /**
+     * Custom class name for the progress bar
+     */
+    className?: string;
+    /**
+     * Custom class name for the progress bar track
+     */
+    classNames?: {
+        base?: string;
+        track?: string;
+        indicator?: string;
+        label?: string;
+        value?: string;
+    };
+}
+
+declare type ProgressRadius = "none" | "sm" | "md" | "lg" | "full";
+
+declare type ProgressSize = "sm" | "md" | "lg";
+
+/**
+ * Text reveal modes
+ */
+export declare type RevealMode = 'letter' | 'word' | 'line';
+
+/**
+ * RevealText Component
+ *
+ * Reveals text character by character, word by word, or line by line
+ * with customizable animation effects and directions.
+ *
+ * @example
+ * <RevealText
+ *   text="Texto que se revela gradualmente"
+ *   mode="letter"
+ *   direction="up"
+ *   staggerDelay={0.05}
+ * />
+ */
+export declare const RevealText: React_2.FC<RevealTextProps>;
+
+/**
+ * RevealText component props
+ */
+export declare interface RevealTextProps extends BaseTextProps {
+    /** How to reveal the text */
+    mode?: RevealMode;
+    /** Animation duration per unit (letter/word) */
+    duration?: number;
+    /** Stagger delay between units */
+    staggerDelay?: number;
+    /** Direction of reveal animation */
+    direction?: TextDirection;
+    /** Initial opacity of hidden text */
+    initialOpacity?: number;
+    /** Animation easing */
+    easing?: TextEasing;
+    /** Reveal with blur effect */
+    withBlur?: boolean;
+    /** Reveal with scale effect */
+    withScale?: boolean;
+    /** Reveal with rotation effect */
+    withRotation?: boolean;
+}
+
+declare type RotateDirection = 'clockwise' | 'counterclockwise';
+
+/**
+ * RotateIn Animation Component
+ *
+ * Animates elements rotating into view with customizable direction and rotation degrees
+ */
+export declare const RotateIn: React.FC<RotateInProps>;
+
+export declare interface RotateInProps extends BaseAnimationProps {
+    direction?: RotateDirection;
+    degrees?: number;
+    transformOrigin?: string;
+}
+
+export declare interface Route {
+    path: string;
+    element: React.ComponentType;
+    label: string;
+    icon?: React.ReactNode;
+    category?: string;
+    exact?: boolean;
+}
+
+export declare interface RouteGroup {
+    label: string;
+    routes: Route[];
+}
+
+export declare interface RouterContextType {
+    routes: Route[];
+    currentPath: string;
+    navigate: (path: string) => void;
+    goBack: () => void;
+    goForward: () => void;
+    addRoute: (route: Route) => void;
+    removeRoute: (path: string) => void;
+    getRoutesByCategory: (category: string) => Route[];
+}
+
+/**
+ * Row data interface
+ */
+declare interface RowData {
+    key: Key;
+    [key: string]: any;
+}
+
+export declare const ScaleContainer: default_2.FC<ScaleContainerProps>;
+
+export declare interface ScaleContainerProps extends BaseAnimatedContainerProps {
+    startScale?: number;
+    endScale?: number;
+    scaleOrigin?: string;
+    bounce?: boolean;
+}
+
+/**
+ * ScaleIn Animation Component
+ *
+ * Animates elements scaling from small to full size with optional hover/tap effects
+ */
+export declare const ScaleIn: React.FC<ScaleInProps>;
+
+export declare interface ScaleInProps extends BaseAnimationProps {
+    from?: number;
+    to?: number;
+    transformOrigin?: string;
+}
+
+export declare interface ScrollConfig {
+    target?: React.RefObject<HTMLElement>;
+    offset?: [string, string];
+    smooth?: boolean;
+}
+
+/**
+ * Selection type - can be "all" or a Set of keys
+ */
+declare type Selection_2 = "all" | Set<Key>;
+
+/**
+ * Selection behavior types
+ */
+declare type SelectionBehavior = "toggle" | "replace";
+
+/**
+ * Selection modes for table rows
+ */
+declare type SelectionMode_2 = "none" | "single" | "multiple";
+
+declare type SeparatorType = 'slash' | 'chevron' | 'arrow' | 'dot' | 'custom';
+
+export declare const Sidebar: default_2.FC<SidebarProps>;
+
+export declare const SidebarContent: default_2.FC<SidebarContentProps>;
+
+export declare interface SidebarContentProps {
+    children: ReactNode;
+    className?: string;
+}
+
+export declare interface SidebarContextType {
+    isOpen: boolean;
+    isMobile: boolean;
+    toggle: () => void;
+    open: () => void;
+    close: () => void;
+}
+
+export declare const SidebarFooter: default_2.FC<SidebarFooterProps>;
+
+export declare interface SidebarFooterProps {
+    children: ReactNode;
+    className?: string;
+}
+
+export declare const SidebarHeader: default_2.FC<SidebarHeaderProps>;
+
+export declare interface SidebarHeaderProps {
+    children: ReactNode;
+    className?: string;
+    showCloseButton?: boolean;
+    onClose?: () => void;
+}
+
+export declare const SidebarItem: default_2.FC<SidebarItemProps>;
+
+export declare interface SidebarItemProps {
+    children: ReactNode;
+    icon?: ReactNode;
+    isActive?: boolean;
+    href?: string;
+    to?: string;
+    onClick?: () => void;
+    className?: string;
+    disabled?: boolean;
+}
+
+export declare interface SidebarProps {
+    children?: ReactNode;
+    className?: string;
+    width?: number | string;
+    position?: "left" | "right";
+    variant?: "permanent" | "temporary" | "persistent";
+    backdrop?: boolean;
+    closeOnBackdropClick?: boolean;
+    closeOnEscape?: boolean;
+}
+
+export declare const SidebarTrigger: default_2.FC<SidebarTriggerProps>;
+
+export declare interface SidebarTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    "aria-label"?: string;
+}
+
+export declare const SlideContainer: default_2.FC<SlideContainerProps>;
+
+export declare interface SlideContainerProps extends BaseAnimatedContainerProps {
+    direction?: SlideDirection;
+    distance?: number;
+    overshoot?: boolean;
+}
+
+declare type SlideDirection = 'up' | 'down' | 'left' | 'right' | 'upLeft' | 'upRight' | 'downLeft' | 'downRight';
+
+declare type SlideDirection_2 = 'up' | 'down' | 'left' | 'right';
+
+/**
+ * SlideIn Animation Component
+ *
+ * Animates elements sliding in from different directions (up, down, left, right)
+ */
+export declare const SlideIn: React.FC<SlideInProps>;
+
+export declare interface SlideInProps extends BaseAnimationProps {
+    direction?: SlideDirection_2;
+    distance?: number;
+}
+
+/**
+ * Sort descriptor interface
+ */
+declare interface SortDescriptor {
+    column?: Key;
+    direction?: "ascending" | "descending";
+}
+
+export declare const Spinner: default_2.FC<SpinnerProps>;
+
+declare interface SpinnerAnimationConfig {
+    duration?: number;
+    delay?: number;
+    repeat?: number;
+    repeatType?: 'loop' | 'reverse' | 'mirror';
+    repeatDelay?: number;
+}
+
+declare type SpinnerColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'neutral';
+
+export declare interface SpinnerProps extends BaseSpinnerProps {
+    /** Optional label text to display below spinner */
+    label?: string;
+    /** Optional overlay mode */
+    overlay?: boolean;
+    /** Overlay background opacity (0-1) */
+    overlayOpacity?: number;
+    /** Custom overlay background color */
+    overlayColor?: string;
+}
+
+declare type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+declare type SpinnerSpeed = 'slow' | 'normal' | 'fast';
+
+declare type SpinnerType = 'rotating' | 'pulse' | 'bounce' | 'wave' | 'grid' | 'ring' | 'dots' | 'bars';
+
+/**
+ * Stagger Animation Component
+ *
+ * Animates multiple children with a staggered delay effect
+ */
+export declare const Stagger: React.FC<StaggerProps>;
+
+export declare const StaggerContainer: default_2.FC<StaggerContainerProps>;
+
+export declare interface StaggerContainerProps extends BaseAnimatedContainerProps {
+    staggerDelay?: number;
+    staggerDirection?: 'normal' | 'reverse' | 'alternate';
+    childSelector?: string;
+}
+
+export declare interface StaggerProps {
+    children: ReactNode[];
+    className?: string;
+    staggerDelay?: number;
+    animationType?: AnimationType;
+    direction?: SlideDirection_2;
+    duration?: number;
+    threshold?: number;
+}
+
+/**
+ * Enhanced Switch component with framer-motion animations
+ * Supports multiple sizes, colors, states, and custom icons
+ * @param props - Switch component properties
+ * @returns JSX element representing a styled switch with smooth animations
+ */
+export declare const Switch: ({ children, value, name, size, color, thumbIcon: ThumbIconComponent, startContent, endContent, isSelected: controlledSelected, defaultSelected, isReadOnly, isDisabled, disableAnimation, className, classNames, onChange, onValueChange, "data-testid": dataTestId, }: SwitchProps) => JSX.Element;
+
+/**
+ * Color variants for Switch component
+ */
+declare type SwitchColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * Props interface for the main Switch component
+ */
+export declare interface SwitchProps {
+    /** Content to render as switch label */
+    children?: ReactNode;
+    /** Value attribute for the switch input */
+    value?: string;
+    /** Name attribute for the switch input */
+    name?: string;
+    /** Size variant of the switch */
+    size?: SwitchSize;
+    /** Color theme of the switch */
+    color?: SwitchColor;
+    /** Custom icon component for thumb */
+    thumbIcon?: React.ComponentType<ThumbIconProps>;
+    /** Content to display at the start of the switch */
+    startContent?: ReactNode;
+    /** Content to display at the end of the switch */
+    endContent?: ReactNode;
+    /** Whether the switch is selected (controlled) */
+    isSelected?: boolean;
+    /** Default selected state (uncontrolled) */
+    defaultSelected?: boolean;
+    /** Whether the switch is read-only */
+    isReadOnly?: boolean;
+    /** Whether the switch is disabled */
+    isDisabled?: boolean;
+    /** Whether to disable animations */
+    disableAnimation?: boolean;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Custom class names for different slots */
+    classNames?: Partial<Record<"base" | "wrapper" | "thumb" | "label" | "startContent" | "endContent" | "thumbIcon" | "hiddenInput", string>>;
+    /** Native change event handler */
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+    /** Value change event handler */
+    onValueChange?: (isSelected: boolean) => void;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Size variants for Switch component
+ */
+declare type SwitchSize = "sm" | "md" | "lg";
+
+export declare const Table: <T extends Record<string, any> = any>({ children, className, color, layout, radius, shadow, maxTableHeight, rowHeight, isVirtualized, hideHeader, isStriped, isCompact, isHeaderSticky, fullWidth, removeWrapper, topContent, bottomContent, topContentPlacement, bottomContentPlacement, showSelectionCheckboxes, sortDescriptor, selectedKeys, defaultSelectedKeys, disabledKeys, disallowEmptySelection, selectionMode, selectionBehavior, disabledBehavior, allowDuplicateSelectionEvents, disableAnimation, isKeyboardNavigationDisabled, columns, items, onRowAction, onCellAction, onSelectionChange, onSortChange, "data-testid": testId, ...props }: TableProps<T>) => JSX.Element;
+
+/**
+ * Table color variants
+ */
+declare type TableColor = "default" | "primary" | "secondary" | "success" | "warning" | "danger";
+
+/**
+ * Table layout types
+ */
+declare type TableLayout = "auto" | "fixed";
+
+/**
+ * Table main component props
+ */
+export declare interface TableProps<T = RowData> {
+    children?: ReactNode;
+    className?: string;
+    color?: TableColor;
+    layout?: TableLayout;
+    radius?: TableRadius;
+    shadow?: TableShadow;
+    maxTableHeight?: number;
+    rowHeight?: number;
+    isVirtualized?: boolean;
+    hideHeader?: boolean;
+    isStriped?: boolean;
+    isCompact?: boolean;
+    isHeaderSticky?: boolean;
+    fullWidth?: boolean;
+    removeWrapper?: boolean;
+    topContent?: ReactNode;
+    bottomContent?: ReactNode;
+    topContentPlacement?: ContentPlacement;
+    bottomContentPlacement?: ContentPlacement;
+    showSelectionCheckboxes?: boolean;
+    sortDescriptor?: SortDescriptor;
+    selectedKeys?: Selection_2;
+    defaultSelectedKeys?: Selection_2;
+    disabledKeys?: Selection_2;
+    disallowEmptySelection?: boolean;
+    selectionMode?: SelectionMode_2;
+    selectionBehavior?: SelectionBehavior;
+    disabledBehavior?: DisabledBehavior;
+    allowDuplicateSelectionEvents?: boolean;
+    disableAnimation?: boolean;
+    isKeyboardNavigationDisabled?: boolean;
+    columns?: ColumnDef<T>[];
+    items?: T[];
+    onRowAction?: (key: Key) => void;
+    onCellAction?: (key: Key) => void;
+    onSelectionChange?: (keys: Selection_2) => void;
+    onSortChange?: (descriptor: SortDescriptor) => void;
+    "data-testid"?: string;
+}
+
+/**
+ * Table radius options
+ */
+declare type TableRadius = "none" | "sm" | "md" | "lg";
+
+export declare const TableRow: <T extends Record<string, any> = any>({ children, className, textValue, item, "data-testid": testId, ...props }: TableRowProps<T>) => JSX.Element;
+
+/**
+ * Table row props
+ */
+declare interface TableRowProps<T = any> {
+    children?: ReactNode;
+    className?: string;
+    textValue?: string;
+    item?: T;
+    "data-testid"?: string;
+}
+
+/**
+ * Table shadow options
+ */
+declare type TableShadow = "none" | "sm" | "md" | "lg";
+
+/**
+ * Animation directions for text reveals
+ */
+export declare type TextDirection = 'left' | 'right' | 'up' | 'down' | 'center';
+
+/**
+ * Easing types for text animations
+ */
+export declare type TextEasing = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | 'backIn' | 'backOut' | 'backInOut' | 'bounceIn' | 'bounceOut' | 'bounceInOut';
+
+/**
+ * Animation trigger types for text animations
+ */
+export declare type TextTrigger = 'inView' | 'hover' | 'focus' | 'manual' | 'immediate';
+
+/**
+ * Props interface for custom thumb icon
+ */
+declare interface ThumbIconProps {
+    /** Whether the switch is selected */
+    isSelected?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+/**
+ * Toast component for displaying notifications
+ * @param props - Toast component properties
+ * @returns JSX element representing a toast notification
+ */
+export declare const Toast: ({ id, type, title, description, closable, action, icon, size, variant, radius, position, className, onRemove, onClose, "data-testid": dataTestId, }: ToastProps) => JSX.Element;
+
+/**
+ * ToastContainer component that renders all active toasts
+ * @param props - ToastContainer component properties
+ * @returns JSX element representing the toast container
+ */
+export declare const ToastContainer: ({ position, className, maxToasts, "data-testid": dataTestId, }: ToastContainerProps) => ReactPortal | null;
+
+/**
+ * Toast container props
+ */
+export declare interface ToastContainerProps {
+    position?: ToastPosition;
+    className?: string;
+    maxToasts?: number;
+    "data-testid"?: string;
+}
+
+/**
+ * Individual toast item interface
+ */
+declare interface ToastItem {
+    id: string;
+    type: ToastType;
+    title?: string;
+    description?: string;
+    duration?: number;
+    closable?: boolean;
+    action?: ReactNode;
+    icon?: ReactNode;
+    position?: ToastPosition;
+    size?: ToastSize;
+    variant?: ToastVariant;
+    radius?: ToastRadius;
+    className?: string;
+    onClose?: (id: string) => void;
+}
+
+/**
+ * Toast options for quick methods
+ */
+declare interface ToastOptions {
+    title?: string;
+    description?: string;
+    duration?: number;
+    closable?: boolean;
+    action?: ReactNode;
+    icon?: ReactNode;
+    position?: ToastPosition;
+    size?: ToastSize;
+    variant?: ToastVariant;
+    radius?: ToastRadius;
+    className?: string;
+    onClose?: (id: string) => void;
+}
+
+/**
+ * Toast positions on the screen
+ */
+declare type ToastPosition = "top" | "top-left" | "top-right" | "bottom" | "bottom-left" | "bottom-right";
+
+/**
+ * Toast component props
+ */
+export declare interface ToastProps extends ToastItem {
+    onRemove: (id: string) => void;
+    "data-testid"?: string;
+}
+
+/**
+ * Toast Provider component
+ * Provides toast functionality to the application
+ * @param props - ToastProvider component properties
+ * @returns JSX element representing the toast provider
+ */
+export declare const ToastProvider: ({ children, position, maxToasts, defaultDuration, }: ToastProviderProps) => JSX.Element;
+
+/**
+ * Toast provider props
+ */
+export declare interface ToastProviderProps {
+    children: ReactNode;
+    position?: ToastPosition;
+    maxToasts?: number;
+    defaultDuration?: number;
+    className?: string;
+}
+
+/**
+ * Toast radius options
+ */
+declare type ToastRadius = "none" | "sm" | "md" | "lg" | "full";
+
+/**
+ * Toast sizes
+ */
+declare type ToastSize = "sm" | "md" | "lg";
+
+/**
+ * Toast types for different notification styles
+ */
+declare type ToastType = "success" | "error" | "warning" | "info" | "default";
+
+/**
+ * Toast variants
+ */
+declare type ToastVariant = "solid" | "bordered" | "flat" | "faded" | "shadow";
+
+export declare const Tooltip: default_2.FC<TooltipProps>;
+
+/**
+ * Animation types for tooltip entrance/exit
+ */
+declare type TooltipAnimation = 'fade' | 'scale' | 'shift' | 'bounce' | 'rotate' | 'slide' | 'zoom' | 'flip' | 'elastic' | 'none';
+
+/**
+ * Advanced animation configuration
+ */
+declare interface TooltipAnimationConfig {
+    /** Animation type */
+    type?: TooltipAnimation;
+    /** Animation speed */
+    speed?: TooltipAnimationSpeed;
+    /** Animation easing */
+    easing?: TooltipAnimationEasing;
+    /** Custom duration in seconds */
+    duration?: number;
+    /** Delay before animation starts */
+    delay?: number;
+    /** Spring configuration for bouncy animations */
+    spring?: {
+        tension?: number;
+        friction?: number;
+        mass?: number;
+    };
+}
+
+/**
+ * Animation easing types
+ */
+declare type TooltipAnimationEasing = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | 'backIn' | 'backOut' | 'backInOut' | 'elasticIn' | 'elasticOut' | 'elasticInOut' | 'bounceIn' | 'bounceOut' | 'bounceInOut';
+
+/**
+ * Animation speed configuration
+ */
+declare type TooltipAnimationSpeed = 'slow' | 'normal' | 'fast' | 'instant';
+
+/**
+ * Arrow configuration
+ */
+declare interface TooltipArrow {
+    /** Whether to show arrow */
+    enabled?: boolean;
+    /** Arrow size in pixels */
+    size?: number;
+    /** Arrow offset from edge */
+    offset?: number;
+}
+
+/**
+ * Delay configuration for tooltip show/hide
+ */
+declare interface TooltipDelay {
+    /** Delay before showing tooltip (ms) */
+    show?: number;
+    /** Delay before hiding tooltip (ms) */
+    hide?: number;
+}
+
+/**
+ * Offset configuration for tooltip positioning
+ */
+declare interface TooltipOffset {
+    mainAxis?: number;
+    crossAxis?: number;
+}
+
+/**
+ * Tooltip placement positions
+ */
+declare type TooltipPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+
+/**
+ * Main Tooltip component props
+ */
+export declare interface TooltipProps extends BaseTooltipProps {
+    /** Children to render as trigger */
+    children: ReactNode;
+    /** Whether children should be wrapped in span */
+    asChild?: boolean;
+}
+
+export declare const TooltipProvider: default_2.FC<TooltipProviderProps>;
+
+/**
+ * Tooltip provider context props
+ */
+export declare interface TooltipProviderProps {
+    /** Default delay configuration */
+    delayDuration?: number;
+    /** Skip delay when moving between tooltips */
+    skipDelayDuration?: number;
+    /** Disable hover card globally */
+    disableHoverableContent?: boolean;
+    /** Children */
+    children: ReactNode;
+}
+
+/**
+ * Size variants for tooltip
+ */
+declare type TooltipSize = 'xs' | 'sm' | 'md' | 'lg';
+
+/**
+ * Tooltip trigger types
+ */
+declare type TooltipTrigger = 'hover' | 'click' | 'focus' | 'manual';
+
+/**
+ * Color variants for tooltip
+ */
+declare type TooltipVariant = 'dark' | 'light' | 'primary' | 'success' | 'warning' | 'error';
+
+export declare interface TransitionConfig {
+    type?: 'spring' | 'tween' | 'keyframes' | 'inertia';
+    duration?: number;
+    delay?: number;
+    ease?: EasingType_2 | number[];
+    damping?: number;
+    stiffness?: number;
+    mass?: number;
+    bounce?: number;
+}
+
+export declare type TriggerType = 'inView' | 'hover' | 'focus' | 'manual' | 'immediate';
+
+/**
+ * TypeWriter Component
+ *
+ * Creates a typewriter effect where text appears character by character,
+ * with optional cursor, deletion, and multiple text cycling.
+ *
+ * @example
+ * <TypeWriter
+ *   text="Hola mundo"
+ *   speed={2}
+ *   showCursor={true}
+ *   cursor="line"
+ * />
+ */
+export declare const TypeWriter: React_2.FC<TypeWriterProps>;
+
+/**
+ * TypeWriter component props
+ */
+export declare interface TypeWriterProps extends BaseTextProps {
+    /** Typing speed in characters per second */
+    speed?: number;
+    /** Cursor style */
+    cursor?: CursorStyle;
+    /** Cursor color */
+    cursorColor?: string;
+    /** Whether to show blinking cursor */
+    showCursor?: boolean;
+    /** Whether to delete text after typing */
+    deleteAfter?: boolean;
+    /** Deletion speed in characters per second */
+    deleteSpeed?: number;
+    /** Pause duration before deletion (in seconds) */
+    pauseBeforeDelete?: number;
+    /** Multiple texts to cycle through */
+    texts?: string[];
+    /** Loop through texts infinitely */
+    loop?: boolean;
+}
+
+/**
+ * Custom hook for managing accordion state and behavior
+ */
+export declare const useAccordion: (config?: UseAccordionConfig) => UseAccordionReturn;
+
+/**
+ * Configuration for useAccordion hook
+ */
+declare interface UseAccordionConfig {
+    /** Selection mode */
+    selectionMode?: AccordionSelectionMode;
+    /** Default expanded keys */
+    defaultExpandedKeys?: string[];
+    /** Controlled expanded keys */
+    expandedKeys?: string[];
+    /** Change handler */
+    onExpandedChange?: (keys: string[]) => void;
+    /** Single selection change handler */
+    onSelectionChange?: (key: string) => void;
+    /** Whether disabled */
+    isDisabled?: boolean;
+}
+
+/**
+ * Return type for useAccordion hook
+ */
+declare interface UseAccordionReturn {
+    /** Currently expanded keys */
+    expandedKeys: string[];
+    /** Check if an item is expanded */
+    isExpanded: (key: string) => boolean;
+    /** Toggle a specific item */
+    toggle: (key: string) => void;
+    /** Expand a specific item */
+    expand: (key: string) => void;
+    /** Collapse a specific item */
+    collapse: (key: string) => void;
+    /** Expand all items */
+    expandAll: () => void;
+    /** Collapse all items */
+    collapseAll: () => void;
+    /** Set expanded keys directly */
+    setExpandedKeys: (keys: string[]) => void;
+}
+
+/**
+ * Custom useAutocomplete hook for managing autocomplete state and behavior
+ */
+export declare function useAutocomplete<T = AutocompleteItemData>(props: AutocompleteProps<T>): UseAutocompleteReturn<T>;
+
+/**
+ * Hook return type for useAutocomplete
+ */
+declare interface UseAutocompleteReturn<T = AutocompleteItemData> {
+    /** Input value state */
+    inputValue: string;
+    /** Selected key state */
+    selectedKey: Key | null;
+    /** Open state */
+    isOpen: boolean;
+    /** Loading state */
+    isLoading: boolean;
+    /** Filtered items */
+    filteredItems: T[];
+    /** Focused item key */
+    focusedKey: Key | null;
+    /** Input props */
+    inputProps: ComponentPropsWithoutRef<"input"> & {
+        ref: default_2.RefObject<HTMLInputElement | null>;
+    };
+    /** Listbox props */
+    listboxProps: ComponentPropsWithoutRef<"ul">;
+    /** Popover props */
+    popoverProps: {
+        isOpen: boolean;
+        onOpenChange: (isOpen: boolean) => void;
+    };
+    /** Clear button props */
+    clearButtonProps: ComponentPropsWithoutRef<"button">;
+    /** Selector button props */
+    selectorButtonProps: ComponentPropsWithoutRef<"button">;
+    /** Container ref for click outside detection */
+    containerRef: default_2.RefObject<HTMLDivElement | null>;
+    /** Methods */
+    clearValue: () => void;
+    selectItem: (key: Key) => void;
+    close: () => void;
+    open: () => void;
+    /** State setters */
+    setInputValue: (value: string) => void;
+    setSelectedKey: (key: Key | null) => void;
+    setIsOpen: (isOpen: boolean) => void;
+}
+
+/**
+ * useAvatar hook for custom Avatar implementations
+ * Handles image loading, fallback logic, and initials generation
+ */
+export declare const useAvatar: (props: AvatarProps) => UseAvatarReturn;
+
+/**
+ * useAvatarGroup hook for custom AvatarGroup implementations
+ * Handles child counting, context creation, and overflow logic
+ */
+export declare const useAvatarGroup: (props: AvatarGroupProps) => UseAvatarGroupReturn;
+
+/**
+ * Avatar Group hook return type for custom implementations
+ */
+declare interface UseAvatarGroupReturn {
+    /** Context value for child avatars */
+    context: AvatarGroupContextValue;
+    /** Number of remaining avatars not displayed */
+    remainingCount: number;
+    /** Whether to show the count indicator */
+    shouldShowCount: boolean;
+    /** Props for the base wrapper element */
+    baseProps: ComponentPropsWithoutRef<"div">;
+    /** Props for the count element */
+    countProps: ComponentPropsWithoutRef<"div">;
+}
+
+/**
+ * Avatar hook return type for custom implementations
+ */
+declare interface UseAvatarReturn {
+    /** Whether the image has loaded successfully */
+    isImgLoaded: boolean;
+    /** Whether to show the fallback content */
+    shouldShowFallback: boolean;
+    /** Generated initials from name */
+    initials: string;
+    /** Props for the image element */
+    imgProps: ComponentPropsWithoutRef<"img">;
+    /** Props for the base wrapper element */
+    baseProps: ComponentPropsWithoutRef<"div">;
+    /** Props for the fallback element */
+    fallbackProps: ComponentPropsWithoutRef<"div">;
+}
+
+export declare const useLibraryNavigation: () => {
+    navigateTo: (path: string, replace?: boolean) => void;
+    goBack: () => void;
+    goForward: () => void;
+    isActive: (path: string, exact?: boolean) => boolean;
+    currentPath: string;
+    getCurrentRoute: () => Route | undefined;
+    getRouteByPath: (path: string) => Route | undefined;
+    routes: Route[];
+};
+
+export declare function useModal(props?: UseModalProps): UseModalReturn;
+
+declare interface UseModalProps {
+    isOpen?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+    onClose?: () => void;
+}
+
+declare interface UseModalReturn {
+    isOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onOpenChange: (isOpen: boolean) => void;
+}
+
+export declare const useMorphingContainer: (morphStates: any[]) => {
+    currentIndex: number;
+    controls: LegacyAnimationControls;
+    morphToNext: () => void;
+    morphToPrevious: () => void;
+    morphToIndex: (index: number) => void;
+};
+
+/**
+ * Custom hook for pagination logic and state management
+ * @param config - Pagination configuration
+ * @returns Pagination state and methods
+ */
+export declare function usePagination(config: UsePaginationConfig): UsePaginationReturn;
+
+/**
+ * Hook configuration for usePagination
+ */
+declare interface UsePaginationConfig {
+    /** Total number of pages */
+    total: number;
+    /** Current page */
+    page?: number;
+    /** Default page */
+    defaultPage?: number;
+    /** Initial page */
+    initialPage?: number;
+    /** Number of siblings to show */
+    siblings?: number;
+    /** Whether to show dots */
+    showDots?: boolean;
+    /** Whether to loop pages */
+    loop?: boolean;
+    /** Callback when page changes */
+    onChange?: (page: number) => void;
+}
+
+/**
+ * Hook to access pagination context
+ */
+export declare const usePaginationContext: () => PaginationContextValue;
+
+/**
+ * Return type for usePagination hook
+ */
+declare interface UsePaginationReturn {
+    /** Current active page */
+    activePage: number;
+    /** Array of pagination items */
+    range: PaginationItemData[];
+    /** Go to specific page */
+    setPage: (page: number) => void;
+    /** Go to next page */
+    next: () => void;
+    /** Go to previous page */
+    previous: () => void;
+    /** Go to first page */
+    first: () => void;
+    /** Go to last page */
+    last: () => void;
+    /** Whether on first page */
+    isFirst: boolean;
+    /** Whether on last page */
+    isLast: boolean;
+    /** Total number of pages */
+    totalPages: number;
+}
+
+export declare const useParallaxContainer: (options?: {
+    speed?: number;
+    direction?: "vertical" | "horizontal" | "both";
+    enableOnMobile?: boolean;
+}) => {
+    isActive: boolean;
+    isMobile: boolean;
+    scrollY: MotionValue<number>;
+    transformValue: {
+        x?: undefined;
+        y?: undefined;
+    } | {
+        x: MotionValue<number>;
+        y?: undefined;
+    } | {
+        x: MotionValue<number>;
+        y: MotionValue<number>;
+    } | {
+        y: MotionValue<number>;
+        x?: undefined;
+    };
+    smoothY: MotionValue<number>;
+    smoothX: MotionValue<number>;
+};
+
+/**
+ * User component - Display user information with avatar and name
+ *
+ * Features:
+ * - Avatar with image, initials, or fallback icon
+ * - Name and description text
+ * - Focusable interaction support
+ * - Customizable styling through classNames
+ * - Responsive design
+ *
+ * @param props - User component properties
+ * @returns JSX element representing a user display
+ */
+export declare const User: ForwardRefExoticComponent<UserProps & RefAttributes<HTMLDivElement>>;
+
+/**
+ * Props interface for the User component
+ */
+export declare interface UserProps {
+    /** Name of the user */
+    name?: string;
+    /** Description or subtitle of the user */
+    description?: ReactNode;
+    /** Whether the user component is focusable */
+    isFocusable?: boolean;
+    /** Props to pass to the avatar component */
+    avatarProps?: AvatarProps_2;
+    /** Additional CSS classes to apply */
+    className?: string;
+    /** Custom class names for different slots */
+    classNames?: Partial<Record<"base" | "wrapper" | "name" | "description", string>>;
+    /** Click handler for the user component */
+    onClick?: () => void;
+    /** Test ID for testing frameworks */
+    "data-testid"?: string;
+}
+
+/**
+ * Custom hook for easy toast management
+ * Provides convenient methods for showing different types of toasts
+ * @returns Object with toast methods
+ */
+export declare const useToast: () => UseToastReturn;
+
+/**
+ * UseToast hook return type
+ */
+declare interface UseToastReturn {
+    toast: (message: string, options?: ToastOptions) => string;
+    success: (message: string, options?: Omit<ToastOptions, "type">) => string;
+    error: (message: string, options?: Omit<ToastOptions, "type">) => string;
+    warning: (message: string, options?: Omit<ToastOptions, "type">) => string;
+    info: (message: string, options?: Omit<ToastOptions, "type">) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+    update: (id: string, updates: Partial<ToastItem>) => void;
+}
+
+/**
+ * Validation behavior options
+ */
+declare type ValidationBehavior = "native" | "aria";
+
+/**
+ * Validation behavior types
+ */
+declare type ValidationBehavior_2 = 'native' | 'aria';
+
+/**
+ * Custom validation error type
+ */
+declare type ValidationError = string | string[];
+
+/**
+ * Validation error type
+ */
+declare type ValidationError_2 = string | string[];
+
+/**
+ * Validation result interface
+ */
+declare interface ValidationResult {
+    /** Indicates whether the field value is valid */
+    isInvalid: boolean;
+    /** Array of validation errors */
+    validationErrors: string[];
+    /** Details about native validation state */
+    validationDetails: {
+        badInput?: boolean;
+        patternMismatch?: boolean;
+        rangeOverflow?: boolean;
+        rangeUnderflow?: boolean;
+        stepMismatch?: boolean;
+        tooLong?: boolean;
+        tooShort?: boolean;
+        typeMismatch?: boolean;
+        valueMissing?: boolean;
+        valid?: boolean;
+    };
+}
+
+/**
+ * Validation result interface
+ */
+declare interface ValidationResult_2 {
+    isInvalid: boolean;
+    validationErrors: string[];
+    validationDetails: Record<string, any>;
+}
+
+export { Variants }
+
+export declare interface ViewportConfig {
+    once?: boolean;
+    margin?: string;
+    amount?: number | 'some' | 'all';
+}
+
+export { }