eglador-ui-react 0.1.0-alpha.10

package/dist/index.d.ts

@@ -0,0 +1,679 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { EmblaOptionsType } from 'embla-carousel';
+import { ClassValue } from 'clsx';
+
+type AccordionVariant = "default" | "bordered" | "filled";
+type AccordionSize = "xs" | "sm" | "md";
+interface AccordionProps {
+    title: React.ReactNode;
+    icon?: React.ReactNode;
+    extra?: React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    variant?: AccordionVariant;
+    size?: AccordionSize;
+    disabled?: boolean;
+    hideChevron?: boolean;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function Accordion({ title, icon, extra, defaultOpen, open, onOpenChange, variant, size, disabled, hideChevron, children, className, }: AccordionProps): react_jsx_runtime.JSX.Element;
+
+type AlertVariant = "soft" | "outline" | "filled";
+type AlertColor = "default" | "primary" | "danger" | "success" | "warning" | "info";
+type AlertSize = "sm" | "md";
+interface AlertProps {
+    variant?: AlertVariant;
+    color?: AlertColor;
+    size?: AlertSize;
+    icon?: React.ReactNode;
+    title?: React.ReactNode;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function Alert({ variant, color, size, icon, title, dismissible, onDismiss, className, children, }: AlertProps): react_jsx_runtime.JSX.Element | null;
+
+type BadgeVariant = "solid" | "soft" | "outline";
+type BadgeColor = "default" | "black" | "primary" | "danger" | "success" | "warning" | "info";
+type BadgeSize = "xs" | "sm" | "md";
+type BadgeShape = "square" | "rounded" | "pill";
+interface BadgeProps {
+    variant?: BadgeVariant;
+    color?: BadgeColor;
+    size?: BadgeSize;
+    shape?: BadgeShape;
+    icon?: React.ReactNode;
+    iconRight?: React.ReactNode;
+    removable?: boolean;
+    onRemove?: () => void;
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Badge({ variant, color, size, shape, icon, iconRight, removable, onRemove, className, children, }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+interface BreadcrumbProps {
+    children: React.ReactNode;
+    className?: string;
+    separator?: React.ReactNode;
+}
+interface BreadcrumbItemProps {
+    children: React.ReactNode;
+    href?: string;
+    className?: string;
+    isActive?: boolean;
+}
+declare function BreadcrumbRoot({ children, className, separator }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbItem({ children, href, className, isActive }: BreadcrumbItemProps): react_jsx_runtime.JSX.Element;
+declare const Breadcrumb: typeof BreadcrumbRoot & {
+    Item: typeof BreadcrumbItem;
+};
+
+type ButtonColor = "default" | "black" | "primary" | "danger" | "success" | "warning" | "info";
+type ButtonSize = "xs" | "sm" | "md";
+type ButtonShape = "square" | "rounded" | "circle";
+type ButtonVariant = "solid" | "outline" | "ghost";
+interface ButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "active"> {
+    variant?: ButtonVariant;
+    color?: ButtonColor;
+    soft?: boolean;
+    size?: ButtonSize;
+    shape?: ButtonShape;
+    icon?: React.ReactNode;
+    iconRight?: React.ReactNode;
+    loading?: boolean;
+    active?: boolean;
+    className?: string;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+type CarouselBreakpointOptions = EmblaOptionsType & {
+    slidesPerView?: number | "auto";
+};
+interface CarouselProps {
+    slides: React.ReactNode[];
+    slidesPerView?: number | "auto";
+    align?: EmblaOptionsType["align"];
+    containScroll?: EmblaOptionsType["containScroll"];
+    dragFree?: boolean;
+    loop?: boolean;
+    axis?: "x" | "y";
+    direction?: "ltr" | "rtl";
+    autoplay?: boolean | Record<string, unknown>;
+    autoScroll?: boolean | Record<string, unknown>;
+    autoHeight?: boolean | Record<string, unknown>;
+    fade?: boolean | Record<string, unknown>;
+    wheelGestures?: boolean | Record<string, unknown>;
+    classNames?: boolean | Record<string, unknown>;
+    parallax?: boolean;
+    opacity?: boolean;
+    lazyLoad?: boolean;
+    showNavigation?: boolean;
+    showPagination?: boolean;
+    scrollToIndex?: number;
+    breakpoints?: Record<string, CarouselBreakpointOptions>;
+    className?: string;
+    viewportClassName?: string;
+    containerClassName?: string;
+    slideClassName?: string;
+    styles?: {
+        controls?: string;
+        navigation?: string;
+        pagination?: string;
+        prevButton?: string;
+        nextButton?: string;
+        dot?: string;
+    };
+}
+declare function Carousel({ slides, slidesPerView, align, containScroll, dragFree, loop, axis, direction, autoplay, autoScroll, autoHeight, fade: fadeProp, wheelGestures: wheelGesturesProp, classNames: classNamesProp, parallax, opacity, lazyLoad, showNavigation, showPagination, scrollToIndex, breakpoints, className, viewportClassName, containerClassName, slideClassName, styles, }: CarouselProps): react_jsx_runtime.JSX.Element | null;
+
+type ButtonGroupVariant = "bordered" | "segmented";
+interface ButtonGroupProps {
+    variant?: ButtonGroupVariant;
+    className?: string;
+    children: React.ReactNode;
+}
+declare function ButtonGroup({ variant, className, children, }: ButtonGroupProps): react_jsx_runtime.JSX.Element;
+
+type CheckboxSize = "xs" | "sm" | "md";
+type CheckboxColor = "default" | "black" | "primary" | "danger" | "success" | "warning" | "info";
+type CheckboxVariant = "default" | "card" | "list";
+interface CheckboxProps {
+    variant?: CheckboxVariant;
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    indeterminate?: boolean;
+    size?: CheckboxSize;
+    color?: CheckboxColor;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+    name?: string;
+    value?: string;
+    id?: string;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
+
+type DrawerSide = "left" | "right" | "top" | "bottom";
+type DrawerSize = "sm" | "md" | "lg" | "full";
+interface DrawerProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: DrawerSide;
+    size?: DrawerSize;
+    closeOnBackdrop?: boolean;
+    closeOnEscape?: boolean;
+    children: React.ReactNode;
+}
+interface DrawerTriggerProps {
+    asChild?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}
+interface DrawerContentProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface DrawerHeaderProps {
+    hideClose?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}
+interface DrawerBodyProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface DrawerFooterProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function DrawerRoot({ open, defaultOpen, onOpenChange, side, size, closeOnBackdrop, closeOnEscape, children, }: DrawerProps): react_jsx_runtime.JSX.Element;
+declare namespace DrawerRoot {
+    var displayName: string;
+}
+declare function DrawerTrigger({ asChild, className, children }: DrawerTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace DrawerTrigger {
+    var displayName: string;
+}
+declare function DrawerContent({ className, children }: DrawerContentProps): React.ReactPortal | null;
+declare namespace DrawerContent {
+    var displayName: string;
+}
+declare function DrawerHeader({ hideClose, className, children }: DrawerHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace DrawerHeader {
+    var displayName: string;
+}
+declare function DrawerBody({ className, children }: DrawerBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace DrawerBody {
+    var displayName: string;
+}
+declare function DrawerFooter({ className, children }: DrawerFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace DrawerFooter {
+    var displayName: string;
+}
+declare const Drawer: typeof DrawerRoot & {
+    Trigger: typeof DrawerTrigger;
+    Content: typeof DrawerContent;
+    Header: typeof DrawerHeader;
+    Body: typeof DrawerBody;
+    Footer: typeof DrawerFooter;
+};
+
+type CheckboxGroupVariant = "bordered" | "segmented";
+interface CheckboxGroupProps {
+    variant?: CheckboxGroupVariant;
+    className?: string;
+    children: React.ReactNode;
+}
+declare function CheckboxGroup({ variant, className, children, }: CheckboxGroupProps): react_jsx_runtime.JSX.Element;
+
+type DropdownSide = "bottom" | "top" | "right" | "left";
+type DropdownAlign = "left" | "right" | "top" | "bottom" | "start" | "center" | "end";
+type DropdownWidth = number | "trigger" | "auto";
+interface DropdownProps {
+    side?: DropdownSide;
+    align?: DropdownAlign;
+    width?: DropdownWidth;
+    maxHeight?: number;
+    scroll?: boolean;
+    autoFlip?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    children: React.ReactNode;
+}
+interface DropdownTriggerProps {
+    className?: string;
+    children?: React.ReactNode;
+    asChild?: boolean;
+}
+interface DropdownContentProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function DropdownTrigger({ className, children, asChild }: DropdownTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownTrigger {
+    var displayName: string;
+}
+declare function DropdownContent({ className, children }: DropdownContentProps): react_jsx_runtime.JSX.Element | null;
+declare namespace DropdownContent {
+    var displayName: string;
+}
+declare const Dropdown: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<HTMLDivElement>> & {
+    Trigger: typeof DropdownTrigger;
+    Content: typeof DropdownContent;
+};
+
+type InputSize = "xs" | "sm" | "md";
+type InputShape = "square" | "rounded";
+type InputVariant = "default" | "outline" | "ghost";
+type InputColor = "default" | "black" | "primary" | "danger" | "success" | "warning" | "info";
+type InputState = "idle" | "error" | "success";
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    variant?: InputVariant;
+    size?: InputSize;
+    shape?: InputShape;
+    color?: InputColor;
+    state?: InputState;
+    icon?: React.ReactNode;
+    iconRight?: React.ReactNode;
+    loading?: boolean;
+    label?: string;
+    errorMessage?: string;
+    successMessage?: string;
+    wrapperClassName?: string;
+    className?: string;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+type InputGroupVariant = "bordered" | "stacked";
+interface InputGroupProps {
+    variant?: InputGroupVariant;
+    className?: string;
+    children: React.ReactNode;
+}
+declare function InputGroup({ variant, className, children, }: InputGroupProps): react_jsx_runtime.JSX.Element;
+
+type LinkVariant = "default" | "underline" | "ghost";
+type LinkColor = "default" | "black" | "primary" | "danger" | "success" | "warning" | "info";
+type LinkSize = "xs" | "sm" | "md";
+interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    variant?: LinkVariant;
+    color?: LinkColor;
+    size?: LinkSize;
+    icon?: React.ReactNode;
+    iconRight?: React.ReactNode;
+    external?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+
+type MediaImageRatio = "1:1" | "16:9" | "4:3" | "1:2" | "free";
+type MediaImageSize = "xs" | "sm" | "md" | "lg";
+type MediaImageShape = "square" | "rounded" | "circle";
+interface MediaImageProps {
+    src: string;
+    alt: string;
+    caption?: string;
+    ratio?: MediaImageRatio;
+    size?: MediaImageSize;
+    shape?: MediaImageShape;
+    children?: React.ReactNode;
+    hideCaption?: boolean;
+    objectFit?: "cover" | "contain" | "fill" | "none";
+    loading?: "lazy" | "eager";
+    onError?: () => void;
+    className?: string;
+}
+declare function MediaImage({ src, alt, caption, ratio, size, shape, children, hideCaption, objectFit, loading, onError, className, }: MediaImageProps): react_jsx_runtime.JSX.Element;
+
+type MediaVideoRatio = "1:1" | "16:9" | "4:3" | "1:2" | "free";
+type MediaVideoSize = "xs" | "sm" | "md";
+type MediaVideoShape = "square" | "rounded" | "circle";
+interface MediaVideoProps {
+    src: string;
+    caption?: string;
+    ratio?: MediaVideoRatio;
+    size?: MediaVideoSize;
+    shape?: MediaVideoShape;
+    children?: React.ReactNode;
+    hideCaption?: boolean;
+    controls?: boolean;
+    preload?: "none" | "metadata" | "auto";
+    autoPlay?: boolean;
+    muted?: boolean;
+    loop?: boolean;
+    poster?: string;
+    onError?: () => void;
+    className?: string;
+}
+declare function MediaVideo({ src, caption, ratio, size, shape, children, hideCaption, controls, preload, autoPlay, muted, loop, poster, onError, className, }: MediaVideoProps): react_jsx_runtime.JSX.Element;
+
+type ModalSize = "sm" | "md" | "lg";
+interface ModalProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    size?: ModalSize;
+    closeOnBackdrop?: boolean;
+    closeOnEscape?: boolean;
+    children: React.ReactNode;
+}
+interface ModalTriggerProps {
+    asChild?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}
+interface ModalContentProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface ModalHeaderProps {
+    icon?: React.ReactNode;
+    hideClose?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}
+interface ModalBodyProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface ModalFooterProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function ModalRoot({ open, defaultOpen, onOpenChange, size, closeOnBackdrop, closeOnEscape, children, }: ModalProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalRoot {
+    var displayName: string;
+}
+declare function ModalTrigger({ asChild, className, children }: ModalTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalTrigger {
+    var displayName: string;
+}
+declare function ModalContent({ className, children }: ModalContentProps): React.ReactPortal | null;
+declare namespace ModalContent {
+    var displayName: string;
+}
+declare function ModalHeader({ icon, hideClose, className, children }: ModalHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalHeader {
+    var displayName: string;
+}
+declare function ModalBody({ className, children }: ModalBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalBody {
+    var displayName: string;
+}
+declare function ModalFooter({ className, children }: ModalFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalFooter {
+    var displayName: string;
+}
+declare const Modal: typeof ModalRoot & {
+    Trigger: typeof ModalTrigger;
+    Content: typeof ModalContent;
+    Header: typeof ModalHeader;
+    Body: typeof ModalBody;
+    Footer: typeof ModalFooter;
+};
+
+interface MultiSelectOption {
+    label: string;
+    value: string;
+    [key: string]: unknown;
+}
+interface MultiSelectProps {
+    value?: string[];
+    onChange?: (values: string[], options?: MultiSelectOption[]) => void;
+    options?: MultiSelectOption[];
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    autoFlip?: boolean;
+    maxHeight?: number;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    maxSelected?: number;
+    maxVisibleChips?: number;
+    clearLabel?: string;
+    selectedLabel?: string;
+    noResultsLabel?: string;
+    noOptionsLabel?: string;
+}
+declare function MultiSelect({ value, onChange, options, placeholder, className, disabled, autoFlip, maxHeight, searchable, searchPlaceholder, maxSelected, maxVisibleChips, clearLabel, selectedLabel, noResultsLabel, noOptionsLabel, }: MultiSelectProps): react_jsx_runtime.JSX.Element;
+
+type NotificationColor = "default" | "primary" | "danger" | "success" | "warning" | "info";
+type NotificationPosition = "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center";
+interface NotificationAction {
+    label: string;
+    onClick: () => void;
+    variant?: "default" | "primary";
+}
+interface NotificationItem {
+    id: string;
+    title?: React.ReactNode;
+    message?: React.ReactNode;
+    icon?: React.ReactNode;
+    color?: NotificationColor;
+    /** Auto-dismiss duration in ms (0 = persistent, default: 5000) */
+    duration?: number;
+    /** Show close button (default: true) */
+    dismissible?: boolean;
+    /** Show progress bar for auto-dismiss countdown */
+    showProgress?: boolean;
+    /** Action buttons */
+    actions?: NotificationAction[];
+    /** Pause auto-dismiss on hover (default: true) */
+    pauseOnHover?: boolean;
+    /** Callback when notification is dismissed */
+    onDismiss?: () => void;
+    /** Timestamp for "time ago" display */
+    timestamp?: Date;
+}
+interface NotificationProps {
+    item: NotificationItem;
+    onDismiss: (id: string) => void;
+}
+interface NotificationContainerProps {
+    position?: NotificationPosition;
+    /** Max visible notifications (older ones hidden, default: 5) */
+    maxVisible?: number;
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Notification({ item, onDismiss }: NotificationProps): react_jsx_runtime.JSX.Element;
+declare function NotificationContainer({ position, maxVisible, className, children, }: NotificationContainerProps): React.ReactPortal;
+declare function useNotification(): {
+    notifications: NotificationItem[];
+    push: (item: Omit<NotificationItem, "id"> & {
+        id?: string;
+    }) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+    update: (id: string, updates: Partial<Omit<NotificationItem, "id">>) => void;
+};
+
+type RadioSize = "xs" | "sm" | "md";
+type RadioColor = "default" | "black" | "primary" | "danger" | "success" | "warning" | "info";
+type RadioVariant = "default" | "card" | "list";
+interface RadioProps {
+    variant?: RadioVariant;
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    size?: RadioSize;
+    color?: RadioColor;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+    name?: string;
+    value?: string;
+    id?: string;
+}
+declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
+
+type RadioGroupVariant = "bordered" | "segmented";
+interface RadioGroupProps {
+    variant?: RadioGroupVariant;
+    className?: string;
+    children: React.ReactNode;
+}
+declare function RadioGroup({ variant, className, children, }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+
+interface SelectOption {
+    label: string;
+    value: string;
+    [key: string]: unknown;
+}
+interface SelectProps {
+    value?: string;
+    onChange?: (value: string, option?: SelectOption) => void;
+    options?: SelectOption[];
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    autoFlip?: boolean;
+    maxHeight?: number;
+}
+declare function Select({ value, onChange, options, placeholder, className, disabled, autoFlip, maxHeight, }: SelectProps): react_jsx_runtime.JSX.Element;
+
+type SwitchSize = "xs" | "sm" | "md";
+type SwitchColor = "default" | "black" | "primary" | "danger" | "success" | "warning" | "info";
+interface SwitchProps {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    size?: SwitchSize;
+    color?: SwitchColor;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+    name?: string;
+    value?: string;
+    id?: string;
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLInputElement>>;
+
+type TableSize = "xs" | "sm" | "md";
+type TableVariant = "default" | "bordered" | "striped";
+type TableShape = "square" | "rounded";
+interface TableProps {
+    size?: TableSize;
+    variant?: TableVariant;
+    shape?: TableShape;
+    fullWidth?: boolean;
+    scrollX?: boolean;
+    scrollY?: boolean;
+    maxHeight?: string;
+    className?: string;
+    children: React.ReactNode;
+}
+interface TableHeadProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface TableBodyProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface TableRowProps {
+    onClick?: () => void;
+    isActive?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}
+interface TableHeaderProps {
+    align?: "left" | "center" | "right";
+    width?: string;
+    className?: string;
+    children?: React.ReactNode;
+}
+interface TableCellProps {
+    align?: "left" | "center" | "right";
+    truncate?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function TableRoot({ size, variant, shape, fullWidth, scrollX, scrollY, maxHeight, className, children, }: TableProps): react_jsx_runtime.JSX.Element;
+declare function TableHead({ className, children }: TableHeadProps): react_jsx_runtime.JSX.Element;
+declare function TableBody({ className, children }: TableBodyProps): react_jsx_runtime.JSX.Element;
+declare function TableRow({ onClick, isActive, className, children }: TableRowProps): react_jsx_runtime.JSX.Element;
+declare function TableHeader({ align, width, className, children }: TableHeaderProps): react_jsx_runtime.JSX.Element;
+declare function TableCell({ align, truncate, className, children }: TableCellProps): react_jsx_runtime.JSX.Element;
+declare const Table: typeof TableRoot & {
+    Head: typeof TableHead;
+    Body: typeof TableBody;
+    Row: typeof TableRow;
+    Header: typeof TableHeader;
+    Cell: typeof TableCell;
+};
+
+type TabsVariant = "default" | "bordered" | "segmented";
+type TabsSize = "xs" | "sm" | "md";
+interface TabsProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    variant?: TabsVariant;
+    size?: TabsSize;
+    className?: string;
+    children: React.ReactNode;
+}
+interface TabsListProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface TabsTriggerProps {
+    value: string;
+    icon?: React.ReactNode;
+    activeClassName?: string;
+    disabled?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+}
+interface TabsContentProps {
+    value: string;
+    className?: string;
+    children: React.ReactNode;
+}
+declare function TabsRoot({ value, defaultValue, onValueChange, variant, size, className, children, }: TabsProps): react_jsx_runtime.JSX.Element;
+declare function TabsList({ className, children }: TabsListProps): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ value, icon, activeClassName, disabled, className, children }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ value, className, children }: TabsContentProps): react_jsx_runtime.JSX.Element | null;
+declare const Tabs: typeof TabsRoot & {
+    List: typeof TabsList;
+    Trigger: typeof TabsTrigger;
+    Content: typeof TabsContent;
+};
+
+type TooltipPosition = "top" | "bottom" | "left" | "right";
+interface TooltipProps {
+    content: React.ReactNode;
+    position?: TooltipPosition;
+    delay?: number;
+    children: React.ReactElement;
+    className?: string;
+}
+declare function Tooltip({ content, position, delay, children, className, }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+interface TypewriterProps {
+    texts: string[];
+    typingSpeed?: number;
+    deletingSpeed?: number;
+    pauseDuration?: number;
+    deleteMode?: "backspace" | "clear";
+    loop?: boolean;
+    startDelay?: number;
+    cursor?: boolean;
+    cursorStyle?: "line" | "block" | "underscore";
+    onComplete?: () => void;
+    className?: string;
+}
+declare function Typewriter({ texts, typingSpeed, deletingSpeed, pauseDuration, deleteMode, loop, startDelay, cursor, cursorStyle, onComplete, className, }: TypewriterProps): react_jsx_runtime.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { Accordion, type AccordionProps, type AccordionSize, type AccordionVariant, Alert, type AlertColor, type AlertProps, type AlertSize, type AlertVariant, Badge, type BadgeColor, type BadgeProps, type BadgeShape, type BadgeSize, type BadgeVariant, Breadcrumb, type BreadcrumbItemProps, type BreadcrumbProps, Button, type ButtonColor, ButtonGroup, type ButtonGroupProps, type ButtonGroupVariant, type ButtonProps, type ButtonShape, type ButtonSize, type ButtonVariant, Carousel, type CarouselBreakpointOptions, type CarouselProps, Checkbox, type CheckboxColor, CheckboxGroup, type CheckboxGroupProps, type CheckboxGroupVariant, type CheckboxProps, type CheckboxSize, type CheckboxVariant, Drawer, type DrawerBodyProps, type DrawerContentProps, type DrawerFooterProps, type DrawerHeaderProps, type DrawerProps, type DrawerSide, type DrawerSize, type DrawerTriggerProps, Dropdown, type DropdownAlign, type DropdownContentProps, type DropdownProps, type DropdownSide, type DropdownTriggerProps, type DropdownWidth, Input, type InputColor, InputGroup, type InputGroupProps, type InputGroupVariant, type InputProps, type InputShape, type InputSize, type InputState, type InputVariant, Link, type LinkColor, type LinkProps, type LinkSize, type LinkVariant, MediaImage, type MediaImageProps, type MediaImageRatio, type MediaImageShape, type MediaImageSize, MediaVideo, type MediaVideoProps, type MediaVideoRatio, type MediaVideoShape, type MediaVideoSize, Modal, type ModalBodyProps, type ModalContentProps, type ModalFooterProps, type ModalHeaderProps, type ModalProps, type ModalSize, type ModalTriggerProps, MultiSelect, type MultiSelectOption, type MultiSelectProps, Notification, type NotificationAction, type NotificationColor, NotificationContainer, type NotificationContainerProps, type NotificationItem, type NotificationPosition, type NotificationProps, Radio, type RadioColor, RadioGroup, type RadioGroupProps, type RadioGroupVariant, type RadioProps, type RadioSize, type RadioVariant, Select, type SelectOption, type SelectProps, Switch, type SwitchColor, type SwitchProps, type SwitchSize, Table, type TableBodyProps, type TableCellProps, type TableHeadProps, type TableHeaderProps, type TableProps, type TableRowProps, type TableShape, type TableSize, type TableVariant, Tabs, type TabsContentProps, type TabsListProps, type TabsProps, type TabsSize, type TabsTriggerProps, type TabsVariant, Tooltip, type TooltipPosition, type TooltipProps, Typewriter, type TypewriterProps, cn, useNotification };