@pixonui/react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1483 @@
+import * as React$1 from 'react';
+import React__default, { RefObject, FormEvent, ReactNode } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ClassValue } from 'clsx';
+
+interface PrimaryButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React__default.ReactNode;
+    leftIcon?: React__default.ReactNode;
+    rightIcon?: React__default.ReactNode;
+}
+declare const PrimaryButton: React__default.ForwardRefExoticComponent<PrimaryButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const buttonVariants: (props?: ({
+    variant?: "alert" | "primary" | "secondary" | "outline" | "ghost" | "danger" | "success" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+    shape?: "default" | "pill" | "square" | null | undefined;
+    shadow?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    /** Whether the button should be rendered as a child component using Slot */
+    asChild?: boolean;
+    /** Icon to display on the left side of the button text */
+    leftIcon?: React__default.ReactNode;
+    /** Icon to display on the right side of the button text */
+    rightIcon?: React__default.ReactNode;
+    /** Whether the button is in a loading state, showing a spinner and disabling interaction */
+    isLoading?: boolean;
+}
+/**
+ * A versatile button component with multiple variants, sizes, and states.
+ * Supports glassmorphism, gradients, and icons.
+ */
+declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface GlowButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React__default.ReactNode;
+    leftIcon?: React__default.ReactNode;
+    rightIcon?: React__default.ReactNode;
+}
+declare const GlowButton: React__default.ForwardRefExoticComponent<GlowButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface MetricCardProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    accent?: 'teal' | 'amber' | 'violet' | 'blue' | 'rose' | 'emerald' | 'indigo';
+    icon: React__default.ReactNode;
+    value: React__default.ReactNode;
+    subtext?: React__default.ReactNode;
+    showWave?: boolean;
+    onClick?: () => void;
+}
+declare const MetricCard: React__default.ForwardRefExoticComponent<MetricCardProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface TextProps extends React__default.HTMLAttributes<HTMLElement> {
+    as?: 'p' | 'span' | 'div' | 'label' | 'code';
+    variant?: 'default' | 'muted' | 'subtle' | 'lead' | 'error' | 'success' | 'warning' | 'info';
+    size?: 'xs' | 'sm' | 'base' | 'lg' | 'xl' | '2xl';
+    weight?: 'light' | 'normal' | 'medium' | 'semibold' | 'bold';
+    code?: boolean;
+    children: React__default.ReactNode;
+}
+declare const Text: React__default.ForwardRefExoticComponent<TextProps & React__default.RefAttributes<HTMLElement>>;
+
+interface HeadingProps extends React__default.HTMLAttributes<HTMLHeadingElement> {
+    as?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold' | 'black';
+    children: React__default.ReactNode;
+}
+declare const Heading: React__default.ForwardRefExoticComponent<HeadingProps & React__default.RefAttributes<HTMLHeadingElement>>;
+
+interface TextGradientProps extends React__default.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Starting color (Tailwind class)
+     * @default 'from-blue-500'
+     */
+    from?: string;
+    /**
+     * Ending color (Tailwind class)
+     * @default 'to-purple-500'
+     */
+    to?: string;
+    /**
+     * Middle color (Tailwind class)
+     */
+    via?: string;
+    /**
+     * Gradient direction
+     * @default 'r'
+     */
+    direction?: 'r' | 'l' | 't' | 'b' | 'tr' | 'tl' | 'br' | 'bl';
+    /**
+     * Enable animated gradient shift
+     * @default false
+     */
+    animate?: boolean;
+}
+declare const TextGradient: React__default.ForwardRefExoticComponent<TextGradientProps & React__default.RefAttributes<HTMLSpanElement>>;
+
+interface ShinyTextProps extends React__default.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * The color of the shimmer effect
+     * @default 'rgba(255,255,255,0.3)'
+     */
+    shimmerColor?: string;
+    /**
+     * Duration of the animation
+     * @default '2s'
+     */
+    duration?: string;
+    /**
+     * Base text color
+     * @default 'currentColor'
+     */
+    baseColor?: string;
+}
+declare const ShinyText: React__default.ForwardRefExoticComponent<ShinyTextProps & React__default.RefAttributes<HTMLSpanElement>>;
+
+interface HeroTextProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The main title text
+     */
+    title: string;
+    /**
+     * Text to be highlighted with a gradient
+     */
+    highlight?: string;
+    /**
+     * Subtitle text below the main title
+     */
+    subtitle?: string;
+    /**
+     * Tailwind gradient classes for the highlight
+     * @default 'from-blue-400 via-indigo-500 to-purple-600'
+     */
+    gradient?: string;
+    /**
+     * Enable entrance animation
+     * @default true
+     */
+    animate?: boolean;
+    /**
+     * Add a subtle glow effect behind the highlighted text
+     * @default true
+     */
+    glow?: boolean;
+}
+declare const HeroText: {
+    ({ title, highlight, subtitle, gradient, animate, glow, className, ...props }: HeroTextProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface LetterPullupProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The text to animate
+     */
+    text: string;
+    /**
+     * Delay between each letter animation in seconds
+     * @default 0.05
+     */
+    delay?: number;
+}
+declare const LetterPullup: {
+    ({ text, delay, className, ...props }: LetterPullupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface LabelProps extends React__default.LabelHTMLAttributes<HTMLLabelElement> {
+    required?: boolean;
+}
+declare const Label: React__default.ForwardRefExoticComponent<LabelProps & React__default.RefAttributes<HTMLLabelElement>>;
+
+declare const inputVariants: (props?: ({
+    hasError?: boolean | null | undefined;
+    hasLeftIcon?: boolean | null | undefined;
+    hasRightIcon?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'size'>, Omit<VariantProps<typeof inputVariants>, 'hasError'> {
+    /** Label text displayed above the input */
+    label?: string;
+    /** Error message displayed below the input. If provided, the input will show an error state. */
+    error?: string;
+    /** Icon to display on the left side inside the input */
+    leftIcon?: React__default.ReactNode;
+    /** Icon to display on the right side inside the input */
+    rightIcon?: React__default.ReactNode;
+    /** Additional CSS classes for the container div */
+    containerClassName?: string;
+}
+/**
+ * A styled text input component with support for labels, error messages, and icons.
+ * Follows the library's glassmorphic design system.
+ */
+declare const TextInput: React__default.ForwardRefExoticComponent<TextInputProps & React__default.RefAttributes<HTMLInputElement>>;
+
+interface CheckboxProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> {
+    label?: string;
+    error?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (event: {
+        target: {
+            checked: boolean;
+        };
+    }) => void;
+}
+declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface SwitchProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'type'> {
+    label?: string;
+    error?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (event: {
+        target: {
+            checked: boolean;
+        };
+    }) => void;
+}
+declare const Switch: React__default.ForwardRefExoticComponent<SwitchProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface SelectOption {
+    label: string;
+    value: string;
+}
+interface SelectProps {
+    label?: string;
+    name?: string;
+    options: SelectOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    error?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface ComboboxProps {
+    children: React__default.ReactNode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    filter?: (value: string, search: string) => boolean;
+    usePopover?: boolean;
+}
+declare function Combobox({ children, value: controlledValue, defaultValue, onValueChange, filter, usePopover }: ComboboxProps): react_jsx_runtime.JSX.Element;
+declare function ComboboxTrigger({ className, children, ...props }: React__default.ButtonHTMLAttributes<HTMLButtonElement>): react_jsx_runtime.JSX.Element;
+declare function ComboboxContent({ className, children, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function ComboboxInput({ className, placeholder, ...props }: React__default.InputHTMLAttributes<HTMLInputElement>): react_jsx_runtime.JSX.Element;
+declare function ComboboxList({ className, children, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function ComboboxEmpty({ className, children, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element | null;
+interface ComboboxItemProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    value: string;
+    children: React__default.ReactNode;
+    textValue?: string;
+}
+declare function ComboboxItem({ className, value, children, textValue, ...props }: ComboboxItemProps): react_jsx_runtime.JSX.Element | null;
+
+interface SliderProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    onChange?: (value: number) => void;
+    disabled?: boolean;
+}
+declare const Slider: React__default.ForwardRefExoticComponent<SliderProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface DatePickerProps {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    placeholder?: string;
+    className?: string;
+}
+declare function DatePicker({ value, onChange, placeholder, className }: DatePickerProps): react_jsx_runtime.JSX.Element;
+
+interface DateTimePickerProps {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    placeholder?: string;
+    className?: string;
+}
+declare function DateTimePicker({ value, onChange, placeholder, className }: DateTimePickerProps): react_jsx_runtime.JSX.Element;
+
+interface TextareaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+    error?: string;
+}
+declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+
+interface RadioGroupProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    value?: string;
+    onChange?: (value: string) => void;
+    name?: string;
+    disabled?: boolean;
+    label?: string;
+}
+declare const RadioGroup: React__default.ForwardRefExoticComponent<RadioGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+interface RadioGroupItemProps extends React__default.InputHTMLAttributes<HTMLInputElement> {
+    value: string;
+    label?: string;
+}
+declare const RadioGroupItem: React__default.ForwardRefExoticComponent<RadioGroupItemProps & React__default.RefAttributes<HTMLInputElement>>;
+
+declare const FormItem: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React__default.ForwardRefExoticComponent<Omit<LabelProps & React__default.RefAttributes<HTMLLabelElement>, "ref"> & React__default.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const FormDescription: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLParagraphElement> & React__default.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLParagraphElement> & React__default.RefAttributes<HTMLParagraphElement>>;
+
+type ToastVariant = 'default' | 'success' | 'error' | 'warning' | 'info' | 'loading';
+interface ToastProps {
+    id: string;
+    title?: string;
+    description?: React__default.ReactNode;
+    variant?: ToastVariant;
+    duration?: number;
+    onDismiss: (id: string) => void;
+}
+declare const Toast: ({ id, title, description, variant, duration, onDismiss, }: ToastProps) => react_jsx_runtime.JSX.Element;
+
+type ToastOptions = Omit<ToastProps, 'id' | 'onDismiss'>;
+interface ToastContextType {
+    toast: (options: ToastOptions) => string;
+    dismiss: (id: string) => void;
+    promise: <T>(promise: Promise<T>, options: {
+        loading: string | ToastOptions;
+        success: string | ((data: T) => ToastOptions);
+        error: string | ((error: any) => ToastOptions);
+    }) => Promise<T>;
+}
+declare const ToastContext: React__default.Context<ToastContextType | undefined>;
+declare function ToastProvider({ children }: {
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type AlertVariant = 'default' | 'success' | 'error' | 'warning' | 'info';
+interface AlertProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    variant?: AlertVariant;
+    icon?: React__default.ReactNode;
+    title?: string;
+    children?: React__default.ReactNode;
+}
+declare const Alert: React__default.ForwardRefExoticComponent<AlertProps & React__default.RefAttributes<HTMLDivElement>>;
+
+type ProgressVariant = 'default' | 'success' | 'warning' | 'danger' | 'gradient';
+type ProgressSize = 'sm' | 'md' | 'lg';
+interface ProgressProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+    variant?: ProgressVariant;
+    size?: ProgressSize;
+    isIndeterminate?: boolean;
+    hasStripe?: boolean;
+    indicatorClassName?: string;
+}
+declare const Progress: React__default.ForwardRefExoticComponent<ProgressProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface AvatarProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    src?: string;
+    alt?: string;
+    fallback?: React__default.ReactNode;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+}
+declare const Avatar: React__default.ForwardRefExoticComponent<AvatarProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface AccordionProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    type?: 'single' | 'multiple';
+    defaultValue?: string | string[];
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    children: React__default.ReactNode;
+}
+declare function Accordion({ type, defaultValue, value, onValueChange, className, children, ...props }: AccordionProps): react_jsx_runtime.JSX.Element;
+interface AccordionItemProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    value: string;
+    children: React__default.ReactNode;
+}
+declare function AccordionItem({ className, value, children, ...props }: AccordionItemProps): react_jsx_runtime.JSX.Element;
+interface AccordionTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React__default.ReactNode;
+}
+declare function AccordionTrigger({ className, children, ...props }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+interface AccordionContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+}
+declare function AccordionContent({ className, children, ...props }: AccordionContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface CalendarProps {
+    className?: string;
+    value?: Date;
+    onChange?: (date: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+}
+declare function Calendar({ className, value, onChange, minDate, maxDate }: CalendarProps): react_jsx_runtime.JSX.Element;
+
+interface TabsProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    defaultValue: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    children: React__default.ReactNode;
+}
+declare function Tabs({ defaultValue, value, onValueChange, className, children, ...props }: TabsProps): react_jsx_runtime.JSX.Element;
+interface TabsListProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+}
+declare function TabsList({ className, children, ...props }: TabsListProps): react_jsx_runtime.JSX.Element;
+interface TabsTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    value: string;
+    children: React__default.ReactNode;
+}
+declare function TabsTrigger({ className, value, children, ...props }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+interface TabsContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    value: string;
+    children: React__default.ReactNode;
+}
+declare function TabsContent({ className, value, children, ...props }: TabsContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface SidebarProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+}
+declare const Sidebar: React__default.ForwardRefExoticComponent<SidebarProps & React__default.RefAttributes<HTMLDivElement>>;
+interface SidebarHeaderProps extends React__default.HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarHeader: React__default.ForwardRefExoticComponent<SidebarHeaderProps & React__default.RefAttributes<HTMLDivElement>>;
+interface SidebarContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarContent: React__default.ForwardRefExoticComponent<SidebarContentProps & React__default.RefAttributes<HTMLDivElement>>;
+interface SidebarFooterProps extends React__default.HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarFooter: React__default.ForwardRefExoticComponent<SidebarFooterProps & React__default.RefAttributes<HTMLDivElement>>;
+interface SidebarItemProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    active?: boolean;
+    icon?: React__default.ReactNode;
+    badge?: React__default.ReactNode;
+}
+declare const SidebarItem: React__default.ForwardRefExoticComponent<SidebarItemProps & React__default.RefAttributes<HTMLButtonElement>>;
+interface SidebarGroupProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    label?: string;
+}
+declare const SidebarGroup: React__default.ForwardRefExoticComponent<SidebarGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface NavbarProps {
+    logo?: React__default.ReactNode;
+    links?: {
+        label: string;
+        href: string;
+    }[];
+    actions?: React__default.ReactNode;
+    className?: string;
+    maxWidth?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+}
+declare function Navbar({ logo, links, actions, className, maxWidth, }: NavbarProps): react_jsx_runtime.JSX.Element;
+
+interface UserMenuProps {
+    name: string;
+    description?: string;
+    avatarSrc?: string;
+    avatarFallback?: string;
+    className?: string;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    align?: 'start' | 'end' | 'center';
+}
+declare function UserMenu({ name, description, avatarSrc, avatarFallback, className, side, align }: UserMenuProps): react_jsx_runtime.JSX.Element;
+
+declare const Breadcrumb: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React__default.ReactNode;
+} & React__default.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React__default.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React__default.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React__default.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React__default.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React__default.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Pagination: {
+    ({ className, ...props }: React__default.ComponentProps<"nav">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React__default.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React__default.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & React__default.ComponentProps<"a">;
+declare const PaginationLink: {
+    ({ className, isActive, ...props }: PaginationLinkProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React__default.ComponentProps<typeof PaginationLink>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React__default.ComponentProps<typeof PaginationLink>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React__default.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function Modal({ isOpen, onClose, children, className }: ModalProps): React__default.ReactPortal;
+declare function ModalHeader({ className, children }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function ModalFooter({ className, children }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function ModalTitle({ className, children }: React__default.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function ModalDescription({ className, children }: React__default.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+
+interface DialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function Dialog({ isOpen, onClose, children, className }: DialogProps): React__default.ReactPortal;
+declare function DialogHeader({ className, children }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DialogFooter({ className, children }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ className, children }: React__default.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ className, children }: React__default.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+
+interface DrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    position?: 'left' | 'right' | 'bottom';
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function Drawer({ isOpen, onClose, position, children, className }: DrawerProps): React__default.ReactPortal | null;
+declare function DrawerHeader({ className, children, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DrawerFooter({ className, children, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DrawerTitle({ className, children, ...props }: React__default.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function DrawerDescription({ className, children, ...props }: React__default.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+
+interface DropdownMenuProps {
+    children: React__default.ReactNode;
+}
+declare function DropdownMenu({ children }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
+interface DropdownMenuTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React__default.ReactNode;
+}
+declare function DropdownMenuTrigger({ className, children, ...props }: DropdownMenuTriggerProps): react_jsx_runtime.JSX.Element;
+interface DropdownMenuContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+    align?: 'start' | 'end' | 'center';
+    side?: 'top' | 'bottom' | 'left' | 'right';
+}
+declare function DropdownMenuContent({ className, children, align, side, ...props }: DropdownMenuContentProps): React__default.ReactPortal | null;
+interface DropdownMenuItemProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React__default.ReactNode;
+}
+declare function DropdownMenuItem({ className, children, ...props }: DropdownMenuItemProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuLabel({ className, children, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+interface PopoverProps {
+    children: React__default.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function Popover({ children, open, onOpenChange }: PopoverProps): react_jsx_runtime.JSX.Element;
+interface PopoverTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React__default.ReactNode;
+}
+declare function PopoverTrigger({ className, children, ...props }: PopoverTriggerProps): react_jsx_runtime.JSX.Element;
+interface PopoverContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+    align?: 'start' | 'end' | 'center';
+    sideOffset?: number;
+}
+declare function PopoverContent({ className, children, align, sideOffset, ...props }: PopoverContentProps): React__default.ReactPortal | null;
+
+type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+interface TooltipProps {
+    content: React__default.ReactNode;
+    children: React__default.ReactNode;
+    position?: TooltipPosition;
+    delay?: number;
+    className?: string;
+}
+declare function Tooltip({ content, children, position, delay, className }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+interface CommandDialogProps extends ComboboxProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+declare function Command({ children, ...props }: ComboboxProps): react_jsx_runtime.JSX.Element;
+declare function CommandDialog({ children, open, onOpenChange, ...props }: CommandDialogProps): React__default.ReactPortal | null;
+declare function CommandInput({ className, ...props }: React__default.InputHTMLAttributes<HTMLInputElement>): react_jsx_runtime.JSX.Element;
+declare function CommandList({ className, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CommandEmpty(props: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CommandGroup({ children, heading, className, ...props }: React__default.HTMLAttributes<HTMLDivElement> & {
+    heading?: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function CommandItem({ className, ...props }: React__default.ComponentProps<typeof ComboboxItem>): react_jsx_runtime.JSX.Element;
+declare function CommandShortcut({ className, ...props }: React__default.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+
+declare function useToast(): ToastContextType;
+
+declare function useTimer(initialSeconds?: number): {
+    seconds: number;
+    isActive: boolean;
+    start: () => void;
+    pause: () => void;
+    reset: () => void;
+    formattedTime: string;
+};
+
+type Side = 'top' | 'bottom' | 'left' | 'right';
+type Align = 'start' | 'center' | 'end';
+interface UseFloatingOptions {
+    side?: Side;
+    align?: Align;
+    sideOffset?: number;
+    alignOffset?: number;
+    isOpen?: boolean;
+}
+interface Position {
+    top: number;
+    left: number;
+}
+declare function useFloating(triggerRef: RefObject<HTMLElement>, contentRef: RefObject<HTMLElement>, options?: UseFloatingOptions): {
+    position: Position;
+    isPositioned: boolean;
+    updatePosition: () => void;
+};
+
+interface UseIntersectionOptions extends IntersectionObserverInit {
+    freezeOnceVisible?: boolean;
+}
+declare function useIntersection(elementRef: RefObject<Element>, { threshold, root, rootMargin, freezeOnceVisible, }?: UseIntersectionOptions): IntersectionObserverEntry | undefined;
+
+interface UseFormOptions<T> {
+    initialValues: T;
+    onSubmit: (values: T) => void | Promise<void>;
+}
+declare function useForm<T extends Record<string, unknown>>({ initialValues, onSubmit, }: UseFormOptions<T>): {
+    values: T;
+    errors: Partial<Record<keyof T, string>>;
+    isSubmitting: boolean;
+    handleChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+    handleSubmit: (e: FormEvent<HTMLFormElement>) => Promise<void>;
+    register: (name: keyof T) => {
+        name: string;
+        value: string | number | readonly string[] | undefined;
+        onChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+        error: Partial<Record<keyof T, string>>[keyof T];
+    };
+    setValues: React$1.Dispatch<React$1.SetStateAction<T>>;
+    setErrors: React$1.Dispatch<React$1.SetStateAction<Partial<Record<keyof T, string>>>>;
+};
+
+type Breakpoint = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+declare function useMediaQuery(query: string): boolean;
+declare function useBreakpoint(breakpoint: Breakpoint): boolean;
+interface ContainerSize {
+    width: number;
+    height: number;
+}
+declare function useContainerQuery(ref: RefObject<HTMLElement>): ContainerSize;
+
+interface ScrollValues {
+    scrollX: number;
+    scrollY: number;
+    scrollProgressX: number;
+    scrollProgressY: number;
+}
+declare function useScroll(): ScrollValues;
+
+declare const surfaceVariants: (props?: ({
+    variant?: "ghost" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SurfaceProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof surfaceVariants> {
+    asChild?: boolean;
+}
+declare const Surface: React__default.ForwardRefExoticComponent<SurfaceProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface ScrollProgressProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    color?: string;
+    height?: number | string;
+    position?: 'top' | 'bottom';
+}
+declare function ScrollProgress({ className, color, height, position, ...props }: ScrollProgressProps): react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants: (props?: ({
+    variant?: "outline" | "danger" | "success" | "default" | "warning" | "info" | "neutral" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React__default.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
+    children: React__default.ReactNode;
+}
+declare const Badge: React__default.ForwardRefExoticComponent<BadgeProps & React__default.RefAttributes<HTMLSpanElement>>;
+
+interface DividerProps extends React__default.HTMLAttributes<HTMLHRElement> {
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const Divider: React__default.ForwardRefExoticComponent<DividerProps & React__default.RefAttributes<HTMLHRElement>>;
+
+interface KbdProps extends React__default.HTMLAttributes<HTMLElement> {
+    children: React__default.ReactNode;
+}
+declare const Kbd: React__default.ForwardRefExoticComponent<KbdProps & React__default.RefAttributes<HTMLElement>>;
+
+interface EmptyStateProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    icon?: React__default.ReactNode;
+    title: string;
+    description?: string;
+    action?: React__default.ReactNode;
+}
+declare const EmptyState: React__default.ForwardRefExoticComponent<EmptyStateProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'circle' | 'text';
+}
+declare function Skeleton({ className, variant, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface TableProps extends React__default.HTMLAttributes<HTMLTableElement> {
+    wrapperClassName?: string;
+    rounded?: boolean;
+    maxHeight?: string | number;
+}
+declare const Table: React__default.ForwardRefExoticComponent<TableProps & React__default.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLTableSectionElement> & React__default.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLTableSectionElement> & React__default.RefAttributes<HTMLTableSectionElement>>;
+interface TableRowProps extends React__default.HTMLAttributes<HTMLTableRowElement> {
+    hoverable?: boolean;
+    optimized?: boolean;
+}
+declare const TableRow: React__default.ForwardRefExoticComponent<TableRowProps & React__default.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React__default.ForwardRefExoticComponent<React__default.ThHTMLAttributes<HTMLTableCellElement> & React__default.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React__default.ForwardRefExoticComponent<React__default.TdHTMLAttributes<HTMLTableCellElement> & React__default.RefAttributes<HTMLTableCellElement>>;
+
+interface Column<T> {
+    key: keyof T | string;
+    header: string;
+    sortable?: boolean;
+    render?: (item: T) => React__default.ReactNode;
+    className?: string;
+}
+interface DataTableProps<T> {
+    data: T[];
+    columns: Column<T>[];
+    searchPlaceholder?: string;
+    searchKeys?: (keyof T)[];
+    onRowClick?: (item: T) => void;
+    className?: string;
+    maxHeight?: number;
+    rounded?: boolean;
+}
+declare function DataTable<T extends Record<string, unknown>>({ data, columns, searchPlaceholder, searchKeys, onRowClick, className, maxHeight, rounded }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface KanbanTask {
+    id: string;
+    columnId: string;
+    title: string;
+    description?: string;
+    priority?: 'low' | 'medium' | 'high' | 'urgent';
+    tags?: string[];
+    assignee?: {
+        name: string;
+        avatar?: string;
+    };
+    dueDate?: string;
+    progress?: number;
+    comments?: number;
+    attachments?: number;
+    timeSpent?: number;
+    blockedBy?: string[];
+    [key: string]: any;
+}
+interface KanbanColumn {
+    id: string;
+    title: string;
+    color?: string;
+    limit?: number;
+}
+interface KanbanProps {
+    columns: KanbanColumn[];
+    tasks: KanbanTask[];
+    onTaskMove?: (taskId: string, toColumnId: string, toTaskId?: string, position?: 'top' | 'bottom') => void;
+    onColumnMove?: (columnId: string, toColumnId: string, position?: 'left' | 'right') => void;
+    onTaskClick?: (task: KanbanTask) => void;
+    onTaskAdd?: (columnId: string, title: string) => void;
+    onTaskFullAdd?: (columnId: string) => void;
+    onTaskRemove?: (taskId: string) => void;
+    onColumnAction?: (columnId: string, action: string) => void;
+    onTaskDrop?: (taskId: string, fromColumnId: string, toColumnId: string, index: number) => void;
+    onTaskDragStart?: (taskId: string) => void;
+    onTaskDragEnd?: (taskId: string) => void;
+    onTaskSelectionChange?: (selectedIds: string[]) => void;
+    onTaskTimerToggle?: (taskId: string) => void;
+    renderCard?: (task: KanbanTask) => ReactNode;
+    className?: string;
+    columnClassName?: string;
+    cardClassName?: string;
+    groupBy?: keyof KanbanTask;
+    accentColor?: string;
+    showTaskCount?: boolean;
+    showDividers?: boolean;
+    columnHeight?: number | string;
+    pageSize?: number;
+    selectable?: boolean;
+    selectedTaskIds?: string[];
+    activeTimerTaskId?: string | null;
+}
+
+declare function Kanban({ columns, tasks, onTaskMove, onColumnMove, onTaskClick, onTaskAdd, onTaskFullAdd, onTaskRemove, onColumnAction, onTaskDrop, onTaskDragStart, onTaskDragEnd, onTaskSelectionChange, onTaskTimerToggle, renderCard, className, columnClassName, cardClassName, groupBy, accentColor, showTaskCount, showDividers, columnHeight, pageSize, selectable, selectedTaskIds, activeTimerTaskId, }: KanbanProps): react_jsx_runtime.JSX.Element;
+
+interface KanbanTaskModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (task: Partial<KanbanTask>) => void;
+    task?: KanbanTask;
+    columnId?: string;
+}
+declare function KanbanTaskModal({ isOpen, onClose, onSave, task, columnId }: KanbanTaskModalProps): react_jsx_runtime.JSX.Element;
+
+interface FilterOption {
+    label: string;
+    value: string;
+}
+interface KanbanFilterBarProps {
+    onSearchChange?: (query: string) => void;
+    onFilterChange?: (filters: Record<string, string[]>) => void;
+    priorityOptions?: FilterOption[];
+    tagOptions?: FilterOption[];
+    assigneeOptions?: FilterOption[];
+    className?: string;
+}
+declare function KanbanFilterBar({ onSearchChange, onFilterChange, priorityOptions, tagOptions, assigneeOptions, className }: KanbanFilterBarProps): react_jsx_runtime.JSX.Element;
+
+interface KanbanCalendarViewProps {
+    tasks: KanbanTask[];
+    onTaskClick?: (task: KanbanTask) => void;
+    onAddTask?: (date: Date) => void;
+    className?: string;
+}
+declare function KanbanCalendarView({ tasks, onTaskClick, onAddTask, className }: KanbanCalendarViewProps): react_jsx_runtime.JSX.Element;
+
+interface ScrollAreaProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'vertical' | 'horizontal' | 'both';
+    scrollbarSize?: 'sm' | 'md' | 'lg';
+}
+declare const ScrollArea: React__default.ForwardRefExoticComponent<ScrollAreaProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const Card: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLHeadingElement> & React__default.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLParagraphElement> & React__default.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+
+interface ImageProps extends React__default.ImgHTMLAttributes<HTMLImageElement> {
+    fallback?: React__default.ReactNode;
+    containerClassName?: string;
+}
+declare const Image: React__default.ForwardRefExoticComponent<ImageProps & React__default.RefAttributes<HTMLImageElement>>;
+
+interface ContainerProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+}
+declare const Container: React__default.ForwardRefExoticComponent<ContainerProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface StackProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    direction?: 'row' | 'col' | 'row-reverse' | 'col-reverse';
+    gap?: number | string;
+    align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+    justify?: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
+    wrap?: boolean;
+}
+declare const Stack: React__default.ForwardRefExoticComponent<StackProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface GridProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    cols?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    gap?: number | string;
+}
+declare const Grid: React__default.ForwardRefExoticComponent<GridProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface BackgroundProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The pattern variant to display
+     * @default 'none'
+     */
+    variant?: 'dots' | 'grid' | 'mesh' | 'gradient' | 'beams' | 'none';
+    /**
+     * Add a subtle noise/grain texture
+     * @default false
+     */
+    noise?: boolean;
+    /**
+     * The color of the pattern (CSS color or variable)
+     * @default 'rgba(255,255,255,0.08)'
+     */
+    patternColor?: string;
+    /**
+     * The size of the pattern (spacing between dots/lines)
+     * @default 24
+     */
+    size?: number;
+    /**
+     * Apply a radial mask to fade the edges
+     * @default 'none'
+     */
+    mask?: 'fade' | 'none';
+    /**
+     * Enable subtle animations for mesh or gradient variants
+     * @default false
+     */
+    animate?: boolean;
+    /**
+     * Make the background follow the mouse (requires relative parent)
+     * @default false
+     */
+    followMouse?: boolean;
+    /**
+     * The background color of the container.
+     * Can be a Tailwind class (e.g., 'bg-zinc-950') or a CSS color.
+     */
+    bgColor?: string;
+}
+declare const Background: React__default.ForwardRefExoticComponent<BackgroundProps & React__default.RefAttributes<HTMLDivElement>>;
+
+type Theme = "dark" | "light" | "system";
+type ThemeProviderProps = {
+    children: React__default.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+};
+type ThemeProviderState = {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+};
+declare function ThemeProvider({ children, defaultTheme, storageKey, ...props }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+declare const useTheme: () => ThemeProviderState;
+
+declare function ThemeToggle(): react_jsx_runtime.JSX.Element;
+
+type ChartDataPoint<T = Record<string, any>> = {
+    label: string;
+    value: number;
+} & T;
+interface ChartContextValue<T = any> {
+    width: number;
+    height: number;
+    data: ChartDataPoint<T>[];
+    maxValue: number;
+    padding: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    hoveredIndex: number | null;
+    setHoveredIndex: (index: number | null) => void;
+}
+declare function useChart<T = any>(): ChartContextValue<T>;
+declare function normalize(value: number, max: number, height: number): number;
+interface ChartContainerProps<T = any> extends React__default.HTMLAttributes<HTMLDivElement> {
+    data: ChartDataPoint<T>[];
+    height?: number;
+    padding?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    children: React__default.ReactNode;
+}
+declare function ChartContainer<T = any>({ data, height, padding, className, children, ...props }: ChartContainerProps<T>): react_jsx_runtime.JSX.Element;
+declare function ChartGrid({ lines }: {
+    lines?: number;
+}): react_jsx_runtime.JSX.Element;
+declare function ChartXAxis(): react_jsx_runtime.JSX.Element;
+declare function ChartTooltip({ renderTooltip }: {
+    renderTooltip?: (data: ChartDataPoint) => React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare function ChartSkeleton(): react_jsx_runtime.JSX.Element;
+
+interface BarChartProps<T = any> {
+    color?: 'cyan' | 'purple' | 'emerald' | 'amber' | 'rose';
+    showValues?: boolean;
+    animationDelay?: number;
+    onValueClick?: (data: ChartDataPoint<T>) => void;
+}
+declare function BarChart<T = any>({ color, showValues, animationDelay, onValueClick }: BarChartProps<T>): react_jsx_runtime.JSX.Element;
+
+interface AreaChartProps<T = any> {
+    color?: 'cyan' | 'purple' | 'emerald' | 'amber' | 'rose';
+    showValues?: boolean;
+    animationDelay?: number;
+    onValueClick?: (data: ChartDataPoint<T>) => void;
+}
+declare function AreaChart<T = any>({ color, showValues, animationDelay, onValueClick }: AreaChartProps<T>): react_jsx_runtime.JSX.Element;
+
+interface LineChartProps<T = any> {
+    color?: 'cyan' | 'purple' | 'emerald' | 'amber' | 'rose';
+    showValues?: boolean;
+    animationDelay?: number;
+    curve?: 'linear' | 'smooth' | 'step';
+    strokeWidth?: number;
+    align?: 'center' | 'edge';
+    onValueClick?: (data: ChartDataPoint<T>) => void;
+}
+declare function LineChart<T = any>({ color, showValues, animationDelay, curve, strokeWidth, align, onValueClick }: LineChartProps<T>): react_jsx_runtime.JSX.Element;
+
+interface PieChartProps<T = any> {
+    innerRadius?: number;
+    padAngle?: number;
+    showLabels?: boolean;
+    colors?: string[];
+    onValueClick?: (data: ChartDataPoint<T>) => void;
+}
+declare function PieChart<T = any>({ innerRadius, padAngle, showLabels, colors, onValueClick }: PieChartProps<T>): react_jsx_runtime.JSX.Element;
+
+type RadarDataPoint<T = Record<string, any>> = {
+    subject: string;
+} & T;
+interface RadarChartProps<T = any> extends React__default.HTMLAttributes<HTMLDivElement> {
+    data: RadarDataPoint<T>[];
+    keys: (keyof T)[];
+    colors?: string[];
+    maxValue?: number;
+    height?: number;
+}
+declare function RadarChart<T = any>({ data, keys, colors, maxValue: userMaxValue, height, className, ...props }: RadarChartProps<T>): react_jsx_runtime.JSX.Element;
+
+interface SparklineProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    data: number[];
+    color?: 'cyan' | 'purple' | 'emerald' | 'amber' | 'rose' | 'white';
+    height?: number;
+    strokeWidth?: number;
+    fill?: boolean;
+}
+declare function Sparkline({ data, color, height, strokeWidth, fill, className, ...props }: SparklineProps): react_jsx_runtime.JSX.Element;
+
+interface YAxisProps {
+    ticks?: number;
+    format?: (value: number) => string;
+}
+declare function ChartYAxis({ ticks, format }: YAxisProps): react_jsx_runtime.JSX.Element;
+
+declare const userPreviewVariants: (props?: ({
+    variant?: "default" | "glass" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface UserPreviewProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof userPreviewVariants> {
+    user: {
+        name: string;
+        email?: string;
+        avatarSrc?: string;
+        role?: string;
+        bio?: string;
+        stats?: {
+            label: string;
+            value: string | number;
+        }[];
+    };
+    onFollow?: () => void;
+    onMessage?: () => void;
+}
+declare const UserPreview: React__default.ForwardRefExoticComponent<UserPreviewProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const timelineItemVariants: (props?: ({
+    status?: "success" | "default" | "error" | "active" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TimelineItemProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof timelineItemVariants> {
+    title: string;
+    date?: string;
+    description?: React__default.ReactNode;
+    icon?: React__default.ReactNode;
+    isLast?: boolean;
+}
+declare const TimelineItem: React__default.ForwardRefExoticComponent<TimelineItemProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const Timeline: ({ children, className }: {
+    children: React__default.ReactNode;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+interface TreeNode {
+    id: string;
+    label: string;
+    icon?: React__default.ReactNode;
+    children?: TreeNode[];
+}
+interface TreeProps {
+    data: TreeNode[];
+    className?: string;
+    onSelect?: (node: TreeNode) => void;
+}
+declare const Tree: ({ data, className, onSelect }: TreeProps) => react_jsx_runtime.JSX.Element;
+
+interface TerminalProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    children: React__default.ReactNode;
+}
+declare const Terminal: React__default.ForwardRefExoticComponent<TerminalProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const TerminalLine: ({ children, prefix, className }: {
+    children: React__default.ReactNode;
+    prefix?: string;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+interface MarqueeProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    pauseOnHover?: boolean;
+    direction?: 'left' | 'right';
+    speed?: 'slow' | 'normal' | 'fast';
+    children: React__default.ReactNode;
+}
+declare const Marquee: ({ className, pauseOnHover, direction, speed, children, ...props }: MarqueeProps) => react_jsx_runtime.JSX.Element;
+
+declare const statusDotVariants: (props?: ({
+    variant?: "success" | "error" | "warning" | "info" | "neutral" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    animate?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface StatusDotProps extends React__default.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof statusDotVariants> {
+}
+declare const StatusDot: React__default.ForwardRefExoticComponent<StatusDotProps & React__default.RefAttributes<HTMLSpanElement>>;
+
+interface FileDropzoneProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onDrop'> {
+    onDrop?: (files: File[]) => void;
+    accept?: Record<string, string[]>;
+    maxFiles?: number;
+    maxSize?: number;
+    label?: string;
+    description?: string;
+}
+declare const FileDropzone: React__default.ForwardRefExoticComponent<FileDropzoneProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const otpInputVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface OTPInputProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange'>, VariantProps<typeof otpInputVariants> {
+    length?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    onComplete?: (value: string) => void;
+    disabled?: boolean;
+    error?: boolean;
+}
+declare const OTPInput: React__default.ForwardRefExoticComponent<OTPInputProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const numberInputVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    error?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface NumberInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange'>, VariantProps<typeof numberInputVariants> {
+    value?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+declare const NumberInput: React__default.ForwardRefExoticComponent<NumberInputProps & React__default.RefAttributes<HTMLInputElement>>;
+
+declare const toggleGroupVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ToggleGroupProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange'>, VariantProps<typeof toggleGroupVariants> {
+    value?: string;
+    onChange?: (value: string) => void;
+    options: {
+        label: string;
+        value: string;
+        icon?: React__default.ReactNode;
+    }[];
+}
+declare const ToggleGroup: React__default.ForwardRefExoticComponent<ToggleGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface RatingProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    max?: number;
+    value?: number;
+    onChange?: (value: number) => void;
+    readOnly?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const Rating: React__default.ForwardRefExoticComponent<RatingProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface StepperProps {
+    steps: {
+        title: string;
+        description?: string;
+    }[];
+    currentStep: number;
+    className?: string;
+    onStepClick?: (step: number) => void;
+}
+declare const Stepper: ({ steps, currentStep, className, onStepClick }: StepperProps) => react_jsx_runtime.JSX.Element;
+
+interface SpotlightProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+    size?: number;
+    color?: string;
+}
+declare const Spotlight: ({ children, className, size, color, ...props }: SpotlightProps) => react_jsx_runtime.JSX.Element;
+
+declare const aiPromptInputVariants: (props?: ({
+    variant?: "ghost" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface Attachment {
+    id: string;
+    name: string;
+    type?: string;
+    url?: string;
+}
+interface AIPromptInputProps extends Omit<React__default.TextareaHTMLAttributes<HTMLTextAreaElement>, 'onSubmit'>, VariantProps<typeof aiPromptInputVariants> {
+    /** Callback fired when the user submits the prompt (Enter or Click) */
+    onSubmit?: (value: string) => void;
+    /** Whether the AI is currently generating a response */
+    isGenerating?: boolean;
+    /** Callback fired when the attach button is clicked. If onFilesSelected is provided, this is ignored. */
+    onAttach?: () => void;
+    /** Callback fired when files are selected via the built-in file picker */
+    onFilesSelected?: (files: FileList) => void;
+    /** Callback fired when the stop button is clicked */
+    onStop?: () => void;
+    /** Callback fired when the microphone button is clicked */
+    onMic?: () => void;
+    /** Maximum number of characters allowed */
+    maxLength?: number;
+    /** Custom footer content to render below the input */
+    footer?: React__default.ReactNode;
+    /** List of attached files to display */
+    attachments?: Attachment[];
+    /** Callback fired when an attachment is removed */
+    onRemoveAttachment?: (attachmentId: string) => void;
+    /** Accepted file types for the built-in file picker */
+    accept?: string;
+    /** Whether to allow multiple files in the built-in file picker */
+    multiple?: boolean;
+}
+/**
+ * A specialized input component for AI prompts with support for attachments,
+ * voice input, and generation control.
+ */
+declare const AIPromptInput: React__default.ForwardRefExoticComponent<AIPromptInputProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+
+declare const aiResponseVariants: (props?: ({
+    variant?: "outline" | "ghost" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AIResponseSource {
+    title: string;
+    url: string;
+}
+interface AIResponseProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof aiResponseVariants> {
+    /** The content of the response */
+    children: React__default.ReactNode;
+    /** Callback fired when the copy button is clicked */
+    onCopy?: () => void;
+    /** Callback fired when the regenerate button is clicked */
+    onRegenerate?: () => void;
+    /** Callback fired when feedback buttons are clicked */
+    onFeedback?: (type: 'up' | 'down') => void;
+    /** Callback fired when the share button is clicked */
+    onShare?: () => void;
+    /** Callback fired when the edit button is clicked */
+    onEdit?: () => void;
+    /** Timestamp string to display (e.g., "Just now", "2 mins ago") */
+    timestamp?: string;
+    /** List of sources/citations to display */
+    sources?: AIResponseSource[];
+    /** Name of the model used (e.g., "GPT-4") */
+    model?: string;
+    /** Usage information (e.g., "245 tokens") */
+    usage?: string | number;
+}
+/**
+ * A container component for displaying AI-generated responses with
+ * built-in actions for copying, regenerating, and providing feedback.
+ */
+declare const AIResponse: React__default.ForwardRefExoticComponent<AIResponseProps & React__default.RefAttributes<HTMLDivElement>>;
+
+type UserStatus = 'online' | 'offline' | 'away' | 'busy';
+interface User {
+    id: string;
+    name: string;
+    avatar?: string;
+    status?: UserStatus;
+    lastSeen?: Date;
+    bio?: string;
+    phone?: string;
+}
+type MessageType = 'text' | 'image' | 'file' | 'system';
+type MessageStatus = 'sending' | 'sent' | 'delivered' | 'read' | 'failed';
+interface ChatAttachment {
+    id: string;
+    type: 'image' | 'file';
+    url: string;
+    name?: string;
+    size?: string;
+}
+interface Message {
+    id: string;
+    content: string;
+    senderId: string;
+    timestamp: Date;
+    status?: MessageStatus;
+    type?: MessageType;
+    attachments?: ChatAttachment[];
+    replyToId?: string;
+    reactions?: Record<string, string[]>;
+}
+interface Conversation {
+    id: string;
+    user: User;
+    lastMessage?: Message;
+    unreadCount?: number;
+    isTyping?: boolean;
+}
+
+interface ChatLayoutProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+}
+declare function ChatLayout({ children, className, ...props }: ChatLayoutProps): react_jsx_runtime.JSX.Element;
+
+interface ChatSidebarProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    conversations: Conversation[];
+    activeId?: string;
+    onSelect?: (id: string) => void;
+    onNewChat?: () => void;
+}
+declare function ChatSidebar({ conversations, activeId, onSelect, onNewChat, className, ...props }: ChatSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface ChatHeaderProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    user: User;
+    onBack?: () => void;
+    onInfo?: () => void;
+}
+declare function ChatHeader({ user, onBack, onInfo, className, ...props }: ChatHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface MessageListProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    messages: Message[];
+    currentUserId: string;
+    onReply?: (message: Message) => void;
+    onReact?: (message: Message, emoji: string) => void;
+    onDelete?: (message: Message) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    isLoadingMore?: boolean;
+}
+declare function MessageList({ messages, currentUserId, className, onReply, onReact, onDelete, onLoadMore, hasMore, isLoadingMore, ...props }: MessageListProps): react_jsx_runtime.JSX.Element;
+
+interface MessageBubbleProps {
+    message: Message;
+    isOwn: boolean;
+    showAvatar?: boolean;
+    showStatus?: boolean;
+    className?: string;
+    onReply?: (message: Message) => void;
+    onReact?: (message: Message, emoji: string) => void;
+    onDelete?: (message: Message) => void;
+}
+declare function MessageBubble({ message, isOwn, showAvatar, showStatus, className, onReply, onReact, onDelete }: MessageBubbleProps): react_jsx_runtime.JSX.Element;
+
+interface ChatInputProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    onSend?: (content: string) => void;
+    onAttach?: () => void;
+    placeholder?: string;
+    users?: User[];
+}
+declare function ChatInput({ onSend, onAttach, placeholder, users, className, ...props }: ChatInputProps): react_jsx_runtime.JSX.Element;
+
+interface ChatProfileProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    user: User;
+    onClose?: () => void;
+}
+declare function ChatProfile({ user, onClose, className, ...props }: ChatProfileProps): react_jsx_runtime.JSX.Element;
+
+declare const motionVariants: (props?: ({
+    preset?: "blur" | "fade" | "spring" | "slide-right" | "slide-left" | "3d-flip" | null | undefined;
+    visibleState?: "blur" | "fade" | "spring" | "slide-right" | "slide-left" | "3d-flip" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface MotionProps extends React__default.HTMLAttributes<HTMLDivElement>, Omit<VariantProps<typeof motionVariants>, 'visibleState'> {
+    asChild?: boolean;
+    viewport?: boolean;
+    visible?: boolean;
+    delay?: number;
+    once?: boolean;
+}
+declare function Motion({ className, preset, viewport, visible, delay, once, asChild, children, style, ...props }: MotionProps): react_jsx_runtime.JSX.Element;
+
+interface MotionGroupProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+    stagger?: number;
+    delay?: number;
+}
+declare function MotionGroup({ children, stagger, delay, className, ...props }: MotionGroupProps): react_jsx_runtime.JSX.Element;
+
+interface TextMotionProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    text: string;
+    type?: 'char' | 'word';
+    stagger?: number;
+    delay?: number;
+}
+declare function TextMotion({ text, type, stagger, delay, className, ...props }: TextMotionProps): react_jsx_runtime.JSX.Element;
+
+interface ParallaxProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    speed?: number;
+    direction?: 'vertical' | 'horizontal';
+}
+declare function Parallax({ children, speed, direction, className, ...props }: ParallaxProps): react_jsx_runtime.JSX.Element;
+
+interface MagneticProps {
+    children: React__default.ReactElement;
+    strength?: number;
+    className?: string;
+}
+declare function Magnetic({ children, strength, className }: MagneticProps): react_jsx_runtime.JSX.Element;
+
+interface NumberTickerProps extends React__default.HTMLAttributes<HTMLSpanElement> {
+    value: number;
+    duration?: number;
+    delay?: number;
+    decimalPlaces?: number;
+}
+declare function NumberTicker({ value, duration, delay, decimalPlaces, className, ...props }: NumberTickerProps): react_jsx_runtime.JSX.Element;
+
+interface RevealProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+    direction?: 'up' | 'down' | 'left' | 'right';
+    duration?: number;
+    delay?: number;
+    boxColor?: string;
+}
+declare function Reveal({ children, direction, duration, delay, boxColor, className, ...props }: RevealProps): react_jsx_runtime.JSX.Element;
+
+declare const separatorVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SeparatorProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof separatorVariants> {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+}
+declare const Separator: React__default.ForwardRefExoticComponent<SeparatorProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface CollapseProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'title'> {
+    title?: React__default.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    children: React__default.ReactNode;
+    triggerClassName?: string;
+    contentClassName?: string;
+}
+declare function Collapse({ title, open: controlledOpen, defaultOpen, onOpenChange, disabled, children, className, triggerClassName, contentClassName, ...props }: CollapseProps): react_jsx_runtime.JSX.Element;
+
+interface PageLoaderProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    variant?: 'spinner' | 'bar' | 'dots' | 'logo' | 'glass';
+    text?: string;
+    fullscreen?: boolean;
+}
+declare function PageLoader({ variant, text, fullscreen, className, ...props }: PageLoaderProps): react_jsx_runtime.JSX.Element;
+
+interface PageTransitionProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    preset?: 'fade' | 'slide-up' | 'scale' | 'blur' | 'none';
+    duration?: number;
+    useViewTransition?: boolean;
+}
+declare function PageTransition({ preset, duration, useViewTransition, className, children, ...props }: PageTransitionProps): react_jsx_runtime.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { AIPromptInput, type AIPromptInputProps, AIResponse, type AIResponseProps, type AIResponseSource, Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, Alert, type AlertProps, type AlertVariant, type Align, AreaChart, type AreaChartProps, type Attachment, Avatar, Background, type BackgroundProps, Badge, type BadgeProps, BarChart, type BarChartProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, type Breakpoint, Button, type ButtonProps, Calendar, type CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, ChartContainer, type ChartContainerProps, type ChartContextValue, type ChartDataPoint, ChartGrid, ChartSkeleton, ChartTooltip, ChartXAxis, ChartYAxis, type ChatAttachment, ChatHeader, ChatInput, ChatLayout, ChatProfile, ChatSidebar, Checkbox, type CheckboxProps, Collapse, type CollapseProps, type Column, Combobox, ComboboxContent, ComboboxEmpty, ComboboxInput, ComboboxItem, type ComboboxItemProps, ComboboxList, type ComboboxProps, ComboboxTrigger, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandShortcut, Container, type ContainerProps, type Conversation, DataTable, DatePicker, type DatePickerProps, DateTimePicker, type DateTimePickerProps, Dialog, DialogDescription, DialogFooter, DialogHeader, type DialogProps, DialogTitle, Divider, Drawer, DrawerDescription, DrawerFooter, DrawerHeader, type DrawerProps, DrawerTitle, DropdownMenu, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuProps, DropdownMenuSeparator, DropdownMenuTrigger, type DropdownMenuTriggerProps, EmptyState, type EmptyStateProps, FileDropzone, type FileDropzoneProps, type FilterOption, FormControl, FormDescription, FormItem, FormLabel, FormMessage, GlowButton, type GlowButtonProps, Grid, type GridProps, Heading, type HeadingProps, HeroText, type HeroTextProps, Image, type ImageProps, Kanban, KanbanCalendarView, type KanbanColumn, KanbanFilterBar, type KanbanFilterBarProps, type KanbanProps, type KanbanTask, KanbanTaskModal, type KanbanTaskModalProps, Kbd, type KbdProps, Label, type LabelProps, LetterPullup, type LetterPullupProps, LineChart, type LineChartProps, Magnetic, type MagneticProps, Marquee, type MarqueeProps, type Message, MessageBubble, MessageList, type MessageStatus, type MessageType, MetricCard, type MetricCardProps, Modal, ModalDescription, ModalFooter, ModalHeader, type ModalProps, ModalTitle, Motion, MotionGroup, type MotionProps, Navbar, NumberInput, type NumberInputProps, NumberTicker, type NumberTickerProps, OTPInput, type OTPInputProps, PageLoader, type PageLoaderProps, PageTransition, type PageTransitionProps, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, Parallax, PieChart, type PieChartProps, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, PrimaryButton, Progress, type ProgressProps, type ProgressSize, type ProgressVariant, RadarChart, type RadarChartProps, type RadarDataPoint, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, Rating, type RatingProps, Reveal, type RevealProps, ScrollArea, type ScrollAreaProps, ScrollProgress, type ScrollProgressProps, type ScrollValues, Select, type SelectOption, type SelectProps, Separator, type SeparatorProps, ShinyText, type ShinyTextProps, type Side, Sidebar, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarProps, Skeleton, type SkeletonProps, Slider, type SliderProps, Sparkline, type SparklineProps, Spotlight, type SpotlightProps, Stack, type StackProps, StatusDot, type StatusDotProps, Stepper, type StepperProps, Surface, type SurfaceProps, Switch, type SwitchProps, Table, TableBody, TableCell, TableHead, TableHeader, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Terminal, TerminalLine, type TerminalProps, Text, TextGradient, type TextGradientProps, TextInput, type TextInputProps, TextMotion, Textarea, type TextareaProps, ThemeProvider, ThemeToggle, Timeline, TimelineItem, type TimelineItemProps, Toast, ToastContext, type ToastContextType, type ToastOptions, type ToastProps, ToastProvider, type ToastVariant, ToggleGroup, type ToggleGroupProps, Tooltip, type TooltipPosition, type TooltipProps, Tree, type TreeNode, type TreeProps, type User, UserMenu, type UserMenuProps, UserPreview, type UserPreviewProps, type UserStatus, type YAxisProps, cn, normalize, useBreakpoint, useChart, useContainerQuery, useFloating, useForm, useIntersection, useMediaQuery, useScroll, useTheme, useTimer, useToast };