react-18-ui-library 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1587 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { ReactNode, RefObject, Component, ErrorInfo } from 'react';
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { DateRange } from 'react-day-picker';
+import { RegisterOptions, SubmitHandler } from 'react-hook-form';
+import { Accept } from 'react-dropzone';
+import { LucideProps, LucideIcon } from 'lucide-react';
+import * as RadixLabel from '@radix-ui/react-label';
+
+interface ThemeTokens {
+    colorPrimary?: string;
+    colorPrimaryHover?: string;
+    colorPrimaryForeground?: string;
+    colorSecondary?: string;
+    colorSecondaryHover?: string;
+    colorSecondaryForeground?: string;
+    colorBackground?: string;
+    colorSurface?: string;
+    colorSurfaceHover?: string;
+    colorBorder?: string;
+    colorBorderFocus?: string;
+    colorText?: string;
+    colorTextMuted?: string;
+    colorTextDisabled?: string;
+    colorError?: string;
+    colorErrorBg?: string;
+    colorSuccess?: string;
+    colorSuccessBg?: string;
+    colorWarning?: string;
+    colorWarningBg?: string;
+    colorInfo?: string;
+    colorInfoBg?: string;
+    colorOverlay?: string;
+    colorNavbar?: string;
+    colorSidebar?: string;
+    colorSidebarText?: string;
+    colorSidebarActive?: string;
+    colorSidebarActiveBg?: string;
+    radiusSm?: string;
+    radiusMd?: string;
+    radiusLg?: string;
+    radiusXl?: string;
+    fontFamilyBase?: string;
+    fontFamilyMono?: string;
+    shadowSm?: string;
+    shadowMd?: string;
+    shadowLg?: string;
+    shadowXl?: string;
+    transitionFast?: string;
+    transitionSpeed?: string;
+    transitionSlow?: string;
+    navbarHeight?: string;
+    sidebarWidth?: string;
+    sidebarCollapsedWidth?: string;
+}
+interface ThemeProviderProps {
+    tokens?: ThemeTokens;
+    children: ReactNode;
+}
+declare function ThemeProvider({ tokens, children }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+
+declare function useTheme(): {
+    getToken: (token: string) => string;
+    setToken: (token: string, value: string) => void;
+};
+
+declare function useMediaQuery(query: string): boolean;
+
+declare function useClickOutside<T extends HTMLElement>(ref: RefObject<T>, handler: (event: MouseEvent | TouchEvent) => void, enabled?: boolean): void;
+
+declare function useDebounce<T>(value: T, delay?: number): T;
+
+type ToastVariant = 'info' | 'success' | 'warning' | 'error';
+type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+interface Toast {
+    id: string;
+    title?: string;
+    description?: string;
+    variant?: ToastVariant;
+    duration?: number;
+}
+interface UseToastReturn {
+    toasts: Toast[];
+    toast: (options: Omit<Toast, 'id'>) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+}
+declare function useToast(): UseToastReturn;
+
+declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((prev: T) => T)) => void, () => void];
+
+interface UseClipboardOptions {
+    timeout?: number;
+    onSuccess?: (value: string) => void;
+    onError?: (error: Error) => void;
+}
+interface UseClipboardReturn {
+    copied: boolean;
+    copy: (value: string) => Promise<void>;
+    reset: () => void;
+}
+declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturn;
+
+interface WindowSize {
+    width: number;
+    height: number;
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+}
+declare function useWindowSize(): WindowSize;
+
+interface UseIntersectionObserverOptions extends IntersectionObserverInit {
+    freezeOnceVisible?: boolean;
+}
+declare function useIntersectionObserver<T extends Element>(options?: UseIntersectionObserverOptions): [RefObject<T>, boolean, IntersectionObserverEntry | null];
+
+type KeyboardModifier = 'ctrl' | 'meta' | 'shift' | 'alt';
+interface KeyboardShortcut {
+    key: string;
+    modifiers?: KeyboardModifier[];
+    handler: (event: KeyboardEvent) => void;
+    enabled?: boolean;
+    preventDefault?: boolean;
+}
+declare function useKeyboard(shortcuts: KeyboardShortcut | KeyboardShortcut[]): void;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+interface NavbarLink {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    active?: boolean;
+    icon?: React.ReactNode;
+}
+interface NavbarProps {
+    logo?: React.ReactNode;
+    links?: NavbarLink[];
+    actions?: React.ReactNode;
+    sticky?: boolean;
+    fixed?: boolean;
+    bordered?: boolean;
+    className?: string;
+    onMenuToggle?: (open: boolean) => void;
+}
+declare function Navbar({ logo, links, actions, sticky, fixed, bordered, className, onMenuToggle, }: NavbarProps): react_jsx_runtime.JSX.Element;
+
+interface SidebarItem {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    href?: string;
+    onClick?: () => void;
+    active?: boolean;
+    badge?: string | number;
+    children?: SidebarItem[];
+}
+interface SidebarProps {
+    items?: SidebarItem[];
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    overlay?: boolean;
+    open?: boolean;
+    onClose?: () => void;
+    className?: string;
+}
+declare function Sidebar({ items, collapsed: controlledCollapsed, defaultCollapsed, onCollapsedChange, header, footer, overlay, open, onClose, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+
+interface AppShellProps {
+    navbar?: NavbarProps;
+    sidebar?: SidebarProps;
+    children: React.ReactNode;
+    defaultSidebarCollapsed?: boolean;
+    className?: string;
+    contentClassName?: string;
+}
+declare function AppShell({ navbar, sidebar, children, defaultSidebarCollapsed, className, contentClassName, }: AppShellProps): react_jsx_runtime.JSX.Element;
+
+type ContainerSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+interface ContainerProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: ContainerSize;
+    centered?: boolean;
+    padded?: boolean;
+}
+declare function Container({ size, centered, padded, className, children, ...props }: ContainerProps): react_jsx_runtime.JSX.Element;
+
+type StackDirection = 'row' | 'col';
+type StackAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+type StackJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+type StackGap = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface StackProps extends React.HTMLAttributes<HTMLDivElement> {
+    direction?: StackDirection;
+    align?: StackAlign;
+    justify?: StackJustify;
+    gap?: StackGap;
+    wrap?: boolean;
+    inline?: boolean;
+}
+declare function Stack({ direction, align, justify, gap, wrap, inline, className, children, ...props }: StackProps): react_jsx_runtime.JSX.Element;
+
+type GridCols = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+type GridGap = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface GridProps extends React.HTMLAttributes<HTMLDivElement> {
+    cols?: GridCols;
+    smCols?: GridCols;
+    mdCols?: GridCols;
+    lgCols?: GridCols;
+    gap?: GridGap;
+    autoFill?: boolean;
+    minColWidth?: string;
+}
+declare function Grid({ cols, smCols, mdCols, lgCols, gap, autoFill, minColWidth, className, style, children, ...props }: GridProps): react_jsx_runtime.JSX.Element;
+
+interface DividerProps {
+    orientation?: 'horizontal' | 'vertical';
+    label?: React.ReactNode;
+    labelPosition?: 'left' | 'center' | 'right';
+    className?: string;
+    style?: React.CSSProperties;
+    id?: string;
+}
+declare function Divider({ orientation, label, labelPosition, className, style, id, }: DividerProps): react_jsx_runtime.JSX.Element;
+
+interface SpacerProps {
+    size?: number | string;
+    axis?: 'horizontal' | 'vertical' | 'both';
+    className?: string;
+}
+declare function Spacer({ size, axis, className }: SpacerProps): react_jsx_runtime.JSX.Element;
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+}
+interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    separator?: React.ReactNode;
+    maxItems?: number;
+    className?: string;
+}
+declare function Breadcrumb({ items, separator, maxItems, className, }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+
+type TabsVariant = 'underline' | 'pill' | 'card';
+interface TabItem {
+    value: string;
+    label: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    badge?: string | number;
+}
+interface TabsProps {
+    items: TabItem[];
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    variant?: TabsVariant;
+    children?: React.ReactNode;
+    className?: string;
+    listClassName?: string;
+}
+declare function Tabs({ items, defaultValue, value, onValueChange, variant, children, className, listClassName, }: TabsProps): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ value, children, className, }: {
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface PaginationProps {
+    page: number;
+    pageSize?: number;
+    total: number;
+    siblingCount?: number;
+    showFirstLast?: boolean;
+    onPageChange: (page: number) => void;
+    className?: string;
+}
+declare function Pagination({ page, pageSize, total, siblingCount, showFirstLast, onPageChange, className, }: PaginationProps): react_jsx_runtime.JSX.Element;
+
+type StepStatus = 'completed' | 'current' | 'upcoming';
+interface Step {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+}
+interface StepIndicatorProps {
+    steps: Step[];
+    currentStep: number;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+}
+declare function StepIndicator({ steps, currentStep, orientation, className, }: StepIndicatorProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "success" | "primary" | "secondary" | "outline" | "ghost" | "danger" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    loading?: boolean;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const iconButtonVariants: (props?: ({
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "danger" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    rounded?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof iconButtonVariants> {
+    icon: React.ReactNode;
+    loading?: boolean;
+    'aria-label': string;
+}
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+type TextFieldSize = 'sm' | 'md' | 'lg';
+interface TextFieldProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix'> {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    size?: TextFieldSize;
+    prefixIcon?: React.ReactNode;
+    prefixImage?: string;
+    prefixText?: string;
+    suffixIcon?: React.ReactNode;
+    suffixImage?: string;
+    suffixText?: string;
+    clearable?: boolean;
+    onClear?: () => void;
+    fullWidth?: boolean;
+    showMaxLength?: boolean;
+    containerClassName?: string;
+    inputClassName?: string;
+}
+declare const TextField: React.ForwardRefExoticComponent<TextFieldProps & React.RefAttributes<HTMLInputElement>>;
+
+interface TextAreaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'prefix'> {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    prefixIcon?: React.ReactNode;
+    prefixImage?: string;
+    suffixIcon?: React.ReactNode;
+    suffixImage?: string;
+    autoResize?: boolean;
+    showCharCount?: boolean;
+    showMaxLength?: boolean;
+    maxLength?: number;
+    fullWidth?: boolean;
+    containerClassName?: string;
+    textareaClassName?: string;
+}
+declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectGroup {
+    label: string;
+    options: SelectOption[];
+}
+interface SelectProps {
+    options?: SelectOption[];
+    groups?: SelectGroup[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    fullWidth?: boolean;
+    className?: string;
+}
+declare function Select({ options, groups, value, defaultValue, onValueChange, placeholder, label, helperText, error, disabled, required, fullWidth, className, }: SelectProps): react_jsx_runtime.JSX.Element;
+
+interface CheckboxProps {
+    label?: string;
+    description?: string;
+    checked?: boolean | 'indeterminate';
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+    disabled?: boolean;
+    required?: boolean;
+    error?: string;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    id?: string;
+}
+declare function Checkbox({ label, description, checked, defaultChecked, onCheckedChange, disabled, required, error, size, className, id: externalId, }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+interface RadioOption {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+interface RadioGroupProps {
+    options: RadioOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+    label?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+}
+declare function RadioGroup({ options, value, defaultValue, onValueChange, orientation, label, error, disabled, required, size, className, }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+
+interface SwitchProps {
+    label?: string;
+    description?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    required?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    labelPosition?: 'left' | 'right';
+    className?: string;
+    id?: string;
+}
+declare function Switch({ label, description, checked, defaultChecked, onCheckedChange, disabled, required, size, labelPosition, className, id: externalId, }: SwitchProps): react_jsx_runtime.JSX.Element;
+
+interface SearchSelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+}
+interface SearchSelectGroup {
+    label: string;
+    options: SearchSelectOption[];
+}
+interface SearchSelectBaseProps {
+    options?: SearchSelectOption[];
+    groups?: SearchSelectGroup[];
+    placeholder?: string;
+    searchPlaceholder?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    fullWidth?: boolean;
+    className?: string;
+    maxSelected?: number;
+}
+interface SearchSelectSingleProps extends SearchSelectBaseProps {
+    multiple?: false;
+    value?: string;
+    onChange?: (value: string) => void;
+}
+interface SearchSelectMultiProps extends SearchSelectBaseProps {
+    multiple: true;
+    value?: string[];
+    onChange?: (value: string[]) => void;
+}
+type SearchSelectProps = SearchSelectSingleProps | SearchSelectMultiProps;
+declare function SearchSelect(props: SearchSelectProps): react_jsx_runtime.JSX.Element;
+
+interface ChipSelectOption {
+    value: string;
+    label: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+type ChipSelectSize = 'sm' | 'md' | 'lg';
+interface ChipSelectProps {
+    options: ChipSelectOption[];
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    multiple?: boolean;
+    maxSelect?: number;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    size?: ChipSelectSize;
+    className?: string;
+    fullWidth?: boolean;
+}
+declare function ChipSelect({ options, value, onChange, multiple, maxSelect, label, helperText, error, disabled, required, size, className, fullWidth, }: ChipSelectProps): react_jsx_runtime.JSX.Element;
+
+type TagSeparator = 'space' | 'comma' | 'enter';
+interface TagInputProps {
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    separator?: TagSeparator[];
+    placeholder?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    maxTags?: number;
+    allowDuplicates?: boolean;
+    fullWidth?: boolean;
+    className?: string;
+}
+declare function TagInput({ value, onChange, separator, placeholder, label, helperText, error, disabled, required, maxTags, allowDuplicates, fullWidth, className, }: TagInputProps): react_jsx_runtime.JSX.Element;
+
+type SliderSize = 'sm' | 'md' | 'lg';
+interface SliderProps {
+    value?: number[];
+    defaultValue?: number[];
+    onValueChange?: (value: number[]) => void;
+    onValueCommit?: (value: number[]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    size?: SliderSize;
+    showTooltip?: boolean;
+    showMarks?: boolean;
+    formatValue?: (value: number) => string;
+    label?: string;
+    helperText?: string;
+    className?: string;
+}
+declare function Slider({ value, defaultValue, onValueChange, onValueCommit, min, max, step, disabled, orientation, size, showTooltip, showMarks, formatValue, label, helperText, className, }: SliderProps): react_jsx_runtime.JSX.Element;
+
+type NumberInputSize = 'sm' | 'md' | 'lg';
+interface NumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'value' | 'onChange' | 'type'> {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number | undefined) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    prefix?: string;
+    suffix?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    size?: NumberInputSize;
+    fullWidth?: boolean;
+    hideControls?: boolean;
+    showMaxLength?: boolean;
+    formatValue?: (value: number) => string;
+    containerClassName?: string;
+}
+declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface CountryCode {
+    code: string;
+    dialCode: string;
+    flag: string;
+    name: string;
+}
+declare const DEFAULT_COUNTRY_CODES: CountryCode[];
+type PhoneInputSize = 'sm' | 'md' | 'lg';
+interface PhoneInputValue {
+    countryCode: CountryCode;
+    number: string;
+    /** Full value e.g. "+91 9876543210" */
+    full: string;
+}
+interface PhoneInputProps {
+    value?: PhoneInputValue;
+    defaultCountry?: string;
+    onChange?: (value: PhoneInputValue) => void;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    size?: PhoneInputSize;
+    fullWidth?: boolean;
+    maxLength?: number;
+    showMaxLength?: boolean;
+    countryCodes?: CountryCode[];
+    className?: string;
+    containerClassName?: string;
+    id?: string;
+}
+declare const PhoneInput: React.ForwardRefExoticComponent<PhoneInputProps & React.RefAttributes<HTMLInputElement>>;
+
+type OTPInputSize = 'sm' | 'md' | 'lg';
+interface OTPInputProps {
+    length?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    onComplete?: (value: string) => void;
+    size?: OTPInputSize;
+    mask?: boolean;
+    disabled?: boolean;
+    error?: string;
+    label?: string;
+    helperText?: string;
+    separator?: boolean;
+    separatorAt?: number[];
+    autoFocus?: boolean;
+    className?: string;
+}
+declare function OTPInput({ length, value: controlledValue, onChange, onComplete, size, mask, disabled, error, label, helperText, separator, separatorAt, autoFocus, className, }: OTPInputProps): react_jsx_runtime.JSX.Element;
+
+type RatingSize = 'sm' | 'md' | 'lg';
+interface RatingProps {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    max?: number;
+    size?: RatingSize;
+    disabled?: boolean;
+    readOnly?: boolean;
+    allowHalf?: boolean;
+    allowClear?: boolean;
+    label?: string;
+    helperText?: string;
+    className?: string;
+    icon?: React.ReactNode;
+    emptyIcon?: React.ReactNode;
+}
+declare function Rating({ value: controlledValue, defaultValue, onChange, max, size, disabled, readOnly, allowHalf, allowClear, label, helperText, className, icon, emptyIcon, }: RatingProps): react_jsx_runtime.JSX.Element;
+
+interface MultiSelectOption {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+interface MultiSelectGroup {
+    label: string;
+    options: MultiSelectOption[];
+}
+interface MultiSelectProps {
+    options?: MultiSelectOption[];
+    groups?: MultiSelectGroup[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    maxSelected?: number;
+    maxDisplayed?: number;
+    size?: 'sm' | 'md' | 'lg';
+    fullWidth?: boolean;
+    className?: string;
+    containerClassName?: string;
+}
+declare function MultiSelect({ options, groups, value: controlledValue, defaultValue, onChange, placeholder, searchPlaceholder, label, helperText, error, disabled, required, searchable, clearable, maxSelected, maxDisplayed, size, fullWidth, className, containerClassName, }: MultiSelectProps): react_jsx_runtime.JSX.Element;
+
+type DatePickerMode = 'single' | 'range';
+type DatePickerSize = 'sm' | 'md' | 'lg';
+interface DatePickerSingleProps {
+    mode?: 'single';
+    value?: Date;
+    defaultValue?: Date;
+    onChange?: (date: Date | undefined) => void;
+}
+interface DatePickerRangeProps {
+    mode: 'range';
+    value?: DateRange;
+    defaultValue?: DateRange;
+    onChange?: (range: DateRange | undefined) => void;
+}
+type DatePickerBaseProps = {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    placeholder?: string;
+    dateFormat?: string;
+    disabled?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    size?: DatePickerSize;
+    fullWidth?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDates?: Date[];
+    /** How many years before current year to show in the year dropdown (default: 10) */
+    yearRangeBefore?: number;
+    /** How many years after current year to show in the year dropdown (default: 5) */
+    yearRangeAfter?: number;
+    className?: string;
+    containerClassName?: string;
+};
+type DatePickerProps = DatePickerBaseProps & (DatePickerSingleProps | DatePickerRangeProps);
+declare function DatePicker(props: DatePickerProps): react_jsx_runtime.JSX.Element;
+
+interface FormFieldProps {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    htmlFor?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function FormField({ label, helperText, error, required, disabled, htmlFor, children, className, }: FormFieldProps): react_jsx_runtime.JSX.Element;
+
+type ValidateFn = (value: unknown) => boolean | string;
+interface CompiledRules {
+    required?: RegisterOptions['required'];
+    minLength?: RegisterOptions['minLength'];
+    maxLength?: RegisterOptions['maxLength'];
+    min?: RegisterOptions['min'];
+    max?: RegisterOptions['max'];
+    pattern?: RegisterOptions['pattern'];
+    validate?: Record<string, ValidateFn>;
+}
+declare abstract class BaseValidator<T extends BaseValidator<T>> {
+    protected _required: string | false;
+    protected _validates: Record<string, ValidateFn>;
+    required(message?: string): T;
+    custom(name: string, fn: ValidateFn, message?: string): T;
+    abstract compile(): CompiledRules;
+}
+declare class StringValidator extends BaseValidator<StringValidator> {
+    private _minLength?;
+    private _maxLength?;
+    private _pattern?;
+    private _mustBeString;
+    mustBe(_type: 'string'): StringValidator;
+    minLength(len: number, message?: string): StringValidator;
+    maxLength(len: number, message?: string): StringValidator;
+    lengthBetween(min: number, max: number, message?: string): StringValidator;
+    length(exact: number, message?: string): StringValidator;
+    shouldMatch(pattern: RegExp, message?: string): StringValidator;
+    shouldBeIn(list: string[], message?: string): StringValidator;
+    notEmpty(message?: string): StringValidator;
+    noSpaces(message?: string): StringValidator;
+    alphanumeric(message?: string): StringValidator;
+    startsWith(prefix: string, message?: string): StringValidator;
+    endsWith(suffix: string, message?: string): StringValidator;
+    compile(): CompiledRules;
+}
+declare class NumberValidator extends BaseValidator<NumberValidator> {
+    private _min?;
+    private _max?;
+    private _maxLength?;
+    private _mustBeNumber;
+    mustBe(_type: 'number'): NumberValidator;
+    min(value: number, message?: string): NumberValidator;
+    max(value: number, message?: string): NumberValidator;
+    between(min: number, max: number, message?: string): NumberValidator;
+    length(digits: number, message?: string): NumberValidator;
+    positive(message?: string): NumberValidator;
+    integer(message?: string): NumberValidator;
+    nonZero(message?: string): NumberValidator;
+    negative(message?: string): NumberValidator;
+    multipleOf(factor: number, message?: string): NumberValidator;
+    compile(): CompiledRules;
+}
+declare class EmailValidator extends BaseValidator<EmailValidator> {
+    private static EMAIL_RE;
+    mustBe(_type: 'string'): EmailValidator;
+    shouldMatch(pattern: RegExp, message?: string): EmailValidator;
+    domain(allowedDomains: string[], message?: string): EmailValidator;
+    blockedDomains(blocked: string[], message?: string): EmailValidator;
+    compile(): CompiledRules;
+}
+declare class UrlValidator extends BaseValidator<UrlValidator> {
+    private static URL_RE;
+    mustBe(_type: 'string'): UrlValidator;
+    httpsOnly(message?: string): UrlValidator;
+    allowedDomains(domains: string[], message?: string): UrlValidator;
+    noTrailingSlash(message?: string): UrlValidator;
+    compile(): CompiledRules;
+}
+declare class TelValidator extends BaseValidator<TelValidator> {
+    length(digits: number, message?: string): TelValidator;
+    minLength(digits: number, message?: string): TelValidator;
+    maxLength(digits: number, message?: string): TelValidator;
+    shouldMatch(pattern: RegExp, message?: string): TelValidator;
+    compile(): CompiledRules;
+}
+declare class BooleanValidator extends BaseValidator<BooleanValidator> {
+    mustBeTrue(message?: string): BooleanValidator;
+    compile(): CompiledRules;
+}
+declare class ArrayValidator extends BaseValidator<ArrayValidator> {
+    private _min?;
+    private _max?;
+    minItems(count: number, message?: string): ArrayValidator;
+    maxItems(count: number, message?: string): ArrayValidator;
+    exactItems(count: number, message?: string): ArrayValidator;
+    noEmpty(message?: string): ArrayValidator;
+    shouldBeIn(list: string[], message?: string): ArrayValidator;
+    compile(): CompiledRules;
+}
+declare class PasswordValidator extends BaseValidator<PasswordValidator> {
+    private _minLength?;
+    private _maxLength?;
+    minLength(len: number, message?: string): PasswordValidator;
+    maxLength(len: number, message?: string): PasswordValidator;
+    hasUppercase(message?: string): PasswordValidator;
+    hasLowercase(message?: string): PasswordValidator;
+    hasDigit(message?: string): PasswordValidator;
+    hasSpecialChar(message?: string): PasswordValidator;
+    noSpaces(message?: string): PasswordValidator;
+    /** Confirm this field matches another field value — pass a getter for the other field */
+    confirmMatch(getOtherValue: () => unknown, message?: string): PasswordValidator;
+    /** Shorthand: minLength(8) + uppercase + lowercase + digit + special char */
+    strong(message?: string): PasswordValidator;
+    compile(): CompiledRules;
+}
+declare class DateValidator extends BaseValidator<DateValidator> {
+    private _toDate;
+    validDate(message?: string): DateValidator;
+    minDate(date: Date, message?: string): DateValidator;
+    maxDate(date: Date, message?: string): DateValidator;
+    notInPast(message?: string): DateValidator;
+    notInFuture(message?: string): DateValidator;
+    between(minDate: Date, maxDate: Date, message?: string): DateValidator;
+    compile(): CompiledRules;
+}
+declare class SelectValidator extends BaseValidator<SelectValidator> {
+    shouldBeIn(list: string[], message?: string): SelectValidator;
+    notEmpty(message?: string): SelectValidator;
+    compile(): CompiledRules;
+}
+declare class FileValidator extends BaseValidator<FileValidator> {
+    /** Max file size in bytes */
+    maxSize(bytes: number, message?: string): FileValidator;
+    allowedTypes(mimeTypes: string[], message?: string): FileValidator;
+    allowedExtensions(exts: string[], message?: string): FileValidator;
+    maxFiles(count: number, message?: string): FileValidator;
+    minFiles(count: number, message?: string): FileValidator;
+    compile(): CompiledRules;
+}
+declare const v: {
+    /** text, textarea fields — lengthBetween, shouldMatch, shouldBeIn, noSpaces, alphanumeric */
+    string: () => StringValidator;
+    /** number fields — between, integer, multipleOf, nonZero, length */
+    number: () => NumberValidator;
+    /** password fields — strong(), hasUppercase, hasDigit, hasSpecialChar, confirmMatch */
+    password: () => PasswordValidator;
+    /** email fields — auto email regex, domain whitelist/blacklist */
+    email: () => EmailValidator;
+    /** url fields — httpsOnly, allowedDomains, noTrailingSlash */
+    url: () => UrlValidator;
+    /** tel/phone fields — length, minLength, maxLength, shouldMatch */
+    tel: () => TelValidator;
+    /** DatePicker fields — minDate, maxDate, notInPast, notInFuture */
+    date: () => DateValidator;
+    /** select/radio fields — shouldBeIn, notEmpty */
+    select: () => SelectValidator;
+    /** checkbox/switch fields — mustBeTrue */
+    boolean: () => BooleanValidator;
+    /** multiselect/chipselect/taginput — minItems, maxItems, exactItems, shouldBeIn, noEmpty */
+    array: () => ArrayValidator;
+    /** FileUpload fields — maxSize, allowedTypes, allowedExtensions, maxFiles, minFiles */
+    file: () => FileValidator;
+};
+type AnyValidator = StringValidator | NumberValidator | PasswordValidator | EmailValidator | UrlValidator | TelValidator | DateValidator | SelectValidator | BooleanValidator | ArrayValidator | FileValidator;
+
+type JSONFieldType = 'text' | 'email' | 'password' | 'number' | 'url' | 'tel' | 'textarea' | 'select' | 'multiselect' | 'searchselect' | 'multisearchselect' | 'chipselect' | 'taginput' | 'checkbox' | 'switch' | 'radio' | 'hidden';
+interface JSONFormOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface JSONFormField {
+    name: string;
+    type: JSONFieldType;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    required?: boolean;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    options?: JSONFormOption[];
+    prefixIcon?: React.ReactNode;
+    prefixImage?: string;
+    prefixText?: string;
+    suffixIcon?: React.ReactNode;
+    suffixImage?: string;
+    suffixText?: string;
+    validation?: {
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: RegExp;
+        validate?: (value: unknown) => boolean | string;
+    };
+    /** Fluent validator built with v.string(), v.number(), v.email() etc. Takes precedence over validation object */
+    validator?: AnyValidator;
+    colSpan?: 1 | 2 | 3;
+    rows?: number;
+    autoResize?: boolean;
+    showCharCount?: boolean;
+}
+interface JSONFormProps {
+    schema: JSONFormField[];
+    defaultValues?: Record<string, unknown>;
+    onSubmit: SubmitHandler<Record<string, unknown>>;
+    onCancel?: () => void;
+    submitLabel?: string;
+    cancelLabel?: string;
+    loading?: boolean;
+    columns?: 1 | 2 | 3;
+    className?: string;
+    actionsClassName?: string;
+}
+declare function JSONForm({ schema, defaultValues, onSubmit, onCancel, submitLabel, cancelLabel, loading, columns, className, actionsClassName, }: JSONFormProps): react_jsx_runtime.JSX.Element;
+
+interface UploadedFile {
+    file: File;
+    id: string;
+    preview?: string;
+    progress?: number;
+    error?: string;
+}
+interface FileUploadProps {
+    accept?: Accept;
+    maxFiles?: number;
+    maxSize?: number;
+    multiple?: boolean;
+    disabled?: boolean;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    files?: UploadedFile[];
+    onFilesChange?: (files: UploadedFile[]) => void;
+    onFileRemove?: (id: string) => void;
+    showPreview?: boolean;
+    className?: string;
+}
+declare function FileUpload({ accept, maxFiles, maxSize, multiple, disabled, label, helperText, error, files, onFilesChange, onFileRemove, showPreview, className, }: FileUploadProps): react_jsx_runtime.JSX.Element;
+
+interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    hoverable?: boolean;
+    clickable?: boolean;
+    bordered?: boolean;
+    shadow?: 'none' | 'sm' | 'md' | 'lg';
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+}
+declare function Card({ header, footer, hoverable, clickable, bordered, shadow, padding, className, children, onClick, ...props }: CardProps): react_jsx_runtime.JSX.Element;
+
+interface BoxProps {
+    as?: 'div' | 'section' | 'article' | 'aside' | 'main' | 'header' | 'footer' | 'nav' | 'span' | 'p';
+    bg?: 'surface' | 'background' | 'primary' | 'secondary' | 'error' | 'success' | 'warning' | 'info';
+    rounded?: 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    shadow?: 'none' | 'sm' | 'md' | 'lg';
+    bordered?: boolean;
+    padding?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    className?: string;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    id?: string;
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+    role?: string;
+    tabIndex?: number;
+    'aria-label'?: string;
+}
+declare function Box({ as: Component, bg, rounded, shadow, bordered, padding, className, children, ...props }: BoxProps): react_jsx_runtime.JSX.Element;
+
+type ImageFit = 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+type ImageRatio = '1/1' | '4/3' | '16/9' | '3/2' | '2/3' | 'auto';
+interface ImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'src'> {
+    src: string;
+    fallbackSrc?: string;
+    fallbackIcon?: React.ReactNode;
+    fit?: ImageFit;
+    ratio?: ImageRatio;
+    lazy?: boolean;
+    rounded?: 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    blur?: boolean;
+    containerClassName?: string;
+}
+declare function Image({ src, fallbackSrc, fallbackIcon, fit, ratio, lazy, rounded, blur, containerClassName, className, alt, ...props }: ImageProps): react_jsx_runtime.JSX.Element;
+
+type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+type AvatarStatus = 'online' | 'offline' | 'away' | 'busy';
+interface AvatarProps {
+    src?: string;
+    alt?: string;
+    name?: string;
+    icon?: React.ReactNode;
+    size?: AvatarSize;
+    status?: AvatarStatus;
+    rounded?: boolean;
+    className?: string;
+}
+interface AvatarGroupProps {
+    avatars: AvatarProps[];
+    max?: number;
+    size?: AvatarSize;
+    className?: string;
+}
+declare function Avatar({ src, alt, name, icon, size, status, rounded, className, }: AvatarProps): react_jsx_runtime.JSX.Element;
+declare function AvatarGroup({ avatars, max, size, className }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants: (props?: ({
+    variant?: "error" | "info" | "success" | "warning" | "primary" | "secondary" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    dot?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends VariantProps<typeof badgeVariants> {
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function Badge({ variant, size, dot, children, className }: BadgeProps): react_jsx_runtime.JSX.Element;
+interface BadgeAnchorProps {
+    children: React.ReactNode;
+    badge?: React.ReactNode;
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+    className?: string;
+}
+declare function BadgeAnchor({ children, badge, position, className }: BadgeAnchorProps): react_jsx_runtime.JSX.Element;
+
+declare const tagVariants: (props?: ({
+    variant?: "error" | "info" | "success" | "warning" | "default" | "primary" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    rounded?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TagProps extends VariantProps<typeof tagVariants> {
+    children: React.ReactNode;
+    icon?: React.ReactNode;
+    removable?: boolean;
+    onRemove?: () => void;
+    className?: string;
+}
+declare function Tag({ variant, size, rounded, children, icon, removable, onRemove, className }: TagProps): react_jsx_runtime.JSX.Element;
+
+type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface IconProps extends Omit<LucideProps, 'size'> {
+    icon: LucideIcon;
+    size?: IconSize | number;
+    color?: string;
+    className?: string;
+}
+declare function Icon({ icon: LucideIconComponent, size, color, className, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+
+interface SVGProps {
+    src?: string;
+    children?: React.ReactNode;
+    width?: number | string;
+    height?: number | string;
+    size?: number | string;
+    color?: string;
+    className?: string;
+    title?: string;
+    role?: string;
+    'aria-label'?: string;
+    'aria-hidden'?: boolean | 'true' | 'false';
+    viewBox?: string;
+    fill?: string;
+    stroke?: string;
+}
+declare function SVG({ src, children, width, height, size, color, className, title, role, viewBox, fill, stroke, ...props }: SVGProps): react_jsx_runtime.JSX.Element;
+
+type SortDirection$1 = 'asc' | 'desc' | null;
+interface TableColumn<T = Record<string, unknown>> {
+    key: string;
+    header: React.ReactNode;
+    accessor?: (row: T) => React.ReactNode;
+    sortable?: boolean;
+    width?: string | number;
+    align?: 'left' | 'center' | 'right';
+    className?: string;
+}
+interface TableProps<T = Record<string, unknown>> {
+    columns: TableColumn<T>[];
+    data: T[];
+    keyExtractor: (row: T, index: number) => string;
+    selectable?: boolean;
+    selectedKeys?: string[];
+    onSelectionChange?: (keys: string[]) => void;
+    sortKey?: string;
+    sortDirection?: SortDirection$1;
+    onSortChange?: (key: string, direction: SortDirection$1) => void;
+    loading?: boolean;
+    emptyMessage?: React.ReactNode;
+    stickyHeader?: boolean;
+    striped?: boolean;
+    hoverable?: boolean;
+    bordered?: boolean;
+    compact?: boolean;
+    className?: string;
+}
+declare function Table<T = Record<string, unknown>>({ columns, data, keyExtractor, selectable, selectedKeys, onSelectionChange, sortKey, sortDirection, onSortChange, loading, emptyMessage, stickyHeader, striped, hoverable, bordered, compact, className, }: TableProps<T>): react_jsx_runtime.JSX.Element;
+
+type SortDirection = 'asc' | 'desc' | null;
+interface DataTableColumn<T = Record<string, unknown>> {
+    key: string;
+    header: React.ReactNode;
+    accessor?: (row: T) => React.ReactNode;
+    sortValue?: (row: T) => string | number;
+    sortable?: boolean;
+    width?: string | number;
+    align?: 'left' | 'center' | 'right';
+    className?: string;
+    pin?: 'left' | 'right';
+}
+interface DataTablePagination {
+    mode: 'client' | 'server';
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    totalRows?: number;
+    page?: number;
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (size: number) => void;
+}
+interface DataTableProps<T = Record<string, unknown>> {
+    columns: DataTableColumn<T>[];
+    data: T[];
+    keyExtractor: (row: T, index: number) => string;
+    selectable?: boolean;
+    selectedKeys?: string[];
+    onSelectionChange?: (keys: string[]) => void;
+    sortKey?: string;
+    sortDirection?: SortDirection;
+    onSortChange?: (key: string, direction: SortDirection) => void;
+    loading?: boolean;
+    emptyMessage?: React.ReactNode;
+    stickyHeader?: boolean;
+    striped?: boolean;
+    hoverable?: boolean;
+    bordered?: boolean;
+    compact?: boolean;
+    className?: string;
+    pagination?: DataTablePagination;
+    toolbar?: React.ReactNode;
+    rowActions?: (row: T) => React.ReactNode;
+    caption?: string;
+}
+declare function DataTable<T = Record<string, unknown>>({ columns, data, keyExtractor, selectable, selectedKeys, onSelectionChange, sortKey, sortDirection, onSortChange, loading, emptyMessage, stickyHeader, striped, hoverable, bordered, compact, className, pagination, toolbar, rowActions, caption, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface ListItemProps {
+    id?: string;
+    primary: React.ReactNode;
+    secondary?: React.ReactNode;
+    leading?: React.ReactNode;
+    trailing?: React.ReactNode;
+    onClick?: () => void;
+    active?: boolean;
+    disabled?: boolean;
+    divider?: boolean;
+    className?: string;
+}
+interface ListProps {
+    items?: ListItemProps[];
+    ordered?: boolean;
+    divided?: boolean;
+    hoverable?: boolean;
+    compact?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function ListItem({ primary, secondary, leading, trailing, onClick, active, disabled, divider, className, }: ListItemProps): react_jsx_runtime.JSX.Element;
+declare function List({ items, ordered, divided, hoverable, compact, children, className, }: ListProps): react_jsx_runtime.JSX.Element;
+
+interface TimelineItem {
+    id: string;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    timestamp?: React.ReactNode;
+    icon?: React.ReactNode;
+    variant?: 'default' | 'success' | 'error' | 'warning' | 'info';
+}
+interface TimelineProps {
+    items: TimelineItem[];
+    orientation?: 'vertical' | 'horizontal';
+    className?: string;
+}
+declare function Timeline({ items, orientation, className }: TimelineProps): react_jsx_runtime.JSX.Element;
+
+interface StatProps {
+    label: string;
+    value: React.ReactNode;
+    delta?: number;
+    deltaLabel?: string;
+    icon?: React.ReactNode;
+    iconBg?: 'primary' | 'success' | 'error' | 'warning' | 'info';
+    description?: string;
+    loading?: boolean;
+    className?: string;
+}
+declare function Stat({ label, value, delta, deltaLabel, icon, iconBg, description, loading, className, }: StatProps): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps {
+    title?: string;
+    description?: string;
+    illustration?: React.ReactNode;
+    icon?: React.ReactNode;
+    action?: React.ReactNode;
+    className?: string;
+}
+declare function EmptyState({ title, description, illustration, icon, action, className, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+
+interface MarkdownReaderProps {
+    children: string;
+    className?: string;
+    codeTheme?: 'dark' | 'light';
+    showLineNumbers?: boolean;
+}
+declare function MarkdownReader({ children, className, codeTheme, showLineNumbers, }: MarkdownReaderProps): react_jsx_runtime.JSX.Element;
+
+interface CollapsibleProps {
+    title: React.ReactNode;
+    children: React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    variant?: 'default' | 'bordered' | 'filled';
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+}
+declare function Collapsible({ title, children, defaultOpen, open: controlledOpen, onOpenChange, disabled, icon, variant, className, triggerClassName, contentClassName, }: CollapsibleProps): react_jsx_runtime.JSX.Element;
+
+interface TreeViewItem {
+    id: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    children?: TreeViewItem[];
+    disabled?: boolean;
+    badge?: React.ReactNode;
+}
+interface TreeViewProps {
+    items: TreeViewItem[];
+    selectedId?: string;
+    onSelect?: (id: string, item: TreeViewItem) => void;
+    defaultExpandedIds?: string[];
+    expandedIds?: string[];
+    onExpandedChange?: (ids: string[]) => void;
+    multiSelect?: boolean;
+    selectedIds?: string[];
+    onMultiSelect?: (ids: string[]) => void;
+    indent?: number;
+    className?: string;
+}
+declare function TreeView({ items, selectedId, onSelect, defaultExpandedIds, expandedIds: controlledExpandedIds, onExpandedChange, multiSelect, selectedIds, onMultiSelect, indent, className, }: TreeViewProps): react_jsx_runtime.JSX.Element;
+
+declare const alertVariants: (props?: ({
+    variant?: "error" | "info" | "success" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AlertProps extends VariantProps<typeof alertVariants> {
+    title?: string;
+    children?: React.ReactNode;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    icon?: React.ReactNode;
+    className?: string;
+}
+declare function Alert({ variant, title, children, dismissible, onDismiss, icon, className, }: AlertProps): react_jsx_runtime.JSX.Element | null;
+
+interface ToastProviderProps {
+    toasts: Toast[];
+    onDismiss: (id: string) => void;
+    position?: ToastPosition;
+}
+declare function ToastProvider({ toasts, onDismiss, position }: ToastProviderProps): react_jsx_runtime.JSX.Element;
+
+type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface SpinnerProps {
+    size?: SpinnerSize;
+    color?: 'primary' | 'secondary' | 'white' | 'current';
+    label?: string;
+    overlay?: boolean;
+    className?: string;
+}
+declare function Spinner({ size, color, label, overlay, className }: SpinnerProps): react_jsx_runtime.JSX.Element;
+
+type SkeletonVariant = 'text' | 'rect' | 'circle';
+interface SkeletonProps {
+    variant?: SkeletonVariant;
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+    className?: string;
+    animated?: boolean;
+}
+declare function Skeleton({ variant, width, height, lines, className, animated, }: SkeletonProps): react_jsx_runtime.JSX.Element;
+interface SkeletonCardProps {
+    showAvatar?: boolean;
+    lines?: number;
+    className?: string;
+}
+declare function SkeletonCard({ showAvatar, lines, className }: SkeletonCardProps): react_jsx_runtime.JSX.Element;
+
+type ProgressVariant = 'primary' | 'success' | 'error' | 'warning' | 'info';
+type ProgressSize = 'xs' | 'sm' | 'md' | 'lg';
+interface ProgressBarProps {
+    value?: number;
+    max?: number;
+    variant?: ProgressVariant;
+    size?: ProgressSize;
+    label?: string;
+    showValue?: boolean;
+    striped?: boolean;
+    animated?: boolean;
+    indeterminate?: boolean;
+    className?: string;
+}
+declare function ProgressBar({ value, max, variant, size, label, showValue, striped, animated, indeterminate, className, }: ProgressBarProps): react_jsx_runtime.JSX.Element;
+
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    reset: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+}
+
+interface FullScreenLoaderState {
+    visible: boolean;
+    text?: string;
+    icon?: React.ReactNode;
+    blur?: boolean;
+}
+interface FullScreenLoaderControls {
+    show: (options?: Partial<Omit<FullScreenLoaderState, 'visible'>>) => void;
+    hide: () => void;
+    update: (options: Partial<Omit<FullScreenLoaderState, 'visible'>>) => void;
+}
+interface FullScreenLoaderProviderProps {
+    children: React.ReactNode;
+    defaultText?: string;
+    defaultBlur?: boolean;
+}
+declare function FullScreenLoaderProvider({ children, defaultText, defaultBlur, }: FullScreenLoaderProviderProps): react_jsx_runtime.JSX.Element;
+declare function useFullScreenLoader(): FullScreenLoaderControls;
+interface FullScreenLoaderProps {
+    visible?: boolean;
+    text?: string;
+    icon?: React.ReactNode;
+    blur?: boolean;
+    className?: string;
+}
+declare function FullScreenLoader({ visible, text, icon, blur, className, }: FullScreenLoaderProps): React.ReactPortal | null;
+
+type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+interface ModalProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footer?: React.ReactNode;
+    size?: ModalSize;
+    showClose?: boolean;
+    closeOnOverlayClick?: boolean;
+    children?: React.ReactNode;
+    trigger?: React.ReactNode;
+    className?: string;
+}
+declare function Modal({ open, defaultOpen, onOpenChange, title, description, footer, size, showClose, closeOnOverlayClick, children, trigger, className, }: ModalProps): react_jsx_runtime.JSX.Element;
+
+type DrawerSide = 'left' | 'right' | 'top' | 'bottom';
+type DrawerSize = 'sm' | 'md' | 'lg' | 'xl';
+interface DrawerProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: DrawerSide;
+    size?: DrawerSize;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footer?: React.ReactNode;
+    showClose?: boolean;
+    children?: React.ReactNode;
+    trigger?: React.ReactNode;
+    className?: string;
+}
+declare function Drawer({ open, defaultOpen, onOpenChange, side, size, title, description, footer, showClose, children, trigger, className, }: DrawerProps): react_jsx_runtime.JSX.Element;
+
+type TooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
+interface TooltipProps {
+    content: React.ReactNode;
+    children: React.ReactNode;
+    placement?: TooltipPlacement;
+    delay?: number;
+    arrow?: boolean;
+    className?: string;
+    contentClassName?: string;
+    disabled?: boolean;
+}
+declare function Tooltip({ content, children, placement, delay, arrow, className, contentClassName, disabled, }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+type PopoverPlacement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+interface PopoverProps {
+    content: React.ReactNode;
+    children: React.ReactNode;
+    placement?: PopoverPlacement;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    showClose?: boolean;
+    arrow?: boolean;
+    className?: string;
+    contentClassName?: string;
+}
+declare function Popover({ content, children, placement, open, defaultOpen, onOpenChange, showClose, arrow, className, contentClassName, }: PopoverProps): react_jsx_runtime.JSX.Element;
+
+interface ContextMenuItem {
+    type?: 'item' | 'separator' | 'label' | 'checkbox' | 'radio';
+    label?: string;
+    icon?: React.ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    destructive?: boolean;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    onClick?: () => void;
+    children?: ContextMenuItem[];
+}
+interface ContextMenuProps {
+    items: ContextMenuItem[];
+    children: React.ReactNode;
+    className?: string;
+}
+declare function ContextMenu({ items, children, className }: ContextMenuProps): react_jsx_runtime.JSX.Element;
+
+type ConfirmVariant = 'default' | 'danger' | 'warning';
+interface ConfirmOptions {
+    title?: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: ConfirmVariant;
+}
+declare function useConfirm(): (options?: ConfirmOptions) => Promise<boolean>;
+interface ConfirmDialogProviderProps {
+    children: React.ReactNode;
+}
+declare function ConfirmDialogProvider({ children }: ConfirmDialogProviderProps): react_jsx_runtime.JSX.Element;
+interface ConfirmDialogProps extends ConfirmOptions {
+    open: boolean;
+    onConfirm: () => void;
+    onCancel: () => void;
+}
+declare function ConfirmDialog({ open, onConfirm, onCancel, title, description, confirmLabel, cancelLabel, variant, }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    shortcut?: string[];
+    group?: string;
+    disabled?: boolean;
+    onSelect: () => void;
+}
+interface CommandGroup {
+    id: string;
+    label: string;
+    items: CommandItem[];
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onClose: () => void;
+    items?: CommandItem[];
+    groups?: CommandGroup[];
+    placeholder?: string;
+    emptyMessage?: string;
+    loading?: boolean;
+    onSearch?: (query: string) => void;
+    hotkey?: string;
+    maxHeight?: number;
+    className?: string;
+}
+declare function CommandPalette({ open, onClose, items, groups, placeholder, emptyMessage, loading, onSearch, maxHeight, className, }: CommandPaletteProps): React.ReactPortal | null;
+declare function useCommandPalette(): {
+    open: boolean;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    toggle: () => void;
+};
+
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+type HeadingSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
+type HeadingWeight = 'normal' | 'medium' | 'semibold' | 'bold';
+interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    level?: HeadingLevel;
+    size?: HeadingSize;
+    weight?: HeadingWeight;
+    truncate?: boolean;
+    color?: 'default' | 'muted' | 'primary' | 'error' | 'success' | 'warning';
+}
+declare function Heading({ level, size, weight, truncate, color, className, children, ...props }: HeadingProps): react_jsx_runtime.JSX.Element;
+
+type TextSize = 'xs' | 'sm' | 'base' | 'lg' | 'xl';
+type TextWeight = 'normal' | 'medium' | 'semibold' | 'bold';
+type TextColor = 'default' | 'muted' | 'disabled' | 'primary' | 'error' | 'success' | 'warning' | 'inherit';
+type TextAs = 'p' | 'span' | 'div' | 'strong' | 'em' | 'small';
+interface TextProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    as?: TextAs;
+    size?: TextSize;
+    weight?: TextWeight;
+    color?: TextColor;
+    truncate?: boolean;
+    clamp?: 1 | 2 | 3 | 4 | 5;
+    italic?: boolean;
+    underline?: boolean;
+}
+declare function Text({ as: Tag, size, weight, color, truncate, clamp, italic, underline, className, children, ...props }: TextProps): react_jsx_runtime.JSX.Element;
+
+interface LabelProps extends React.ComponentPropsWithoutRef<typeof RadixLabel.Root> {
+    required?: boolean;
+    optional?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+declare function Label({ required, optional, size, className, children, ...props }: LabelProps): react_jsx_runtime.JSX.Element;
+
+type CodeTheme = 'dark' | 'light';
+interface CodeProps extends React.HTMLAttributes<HTMLElement> {
+    block?: boolean;
+    language?: string;
+    theme?: CodeTheme;
+    showLineNumbers?: boolean;
+    copyable?: boolean;
+    filename?: string;
+}
+declare function Code({ block, language, theme, showLineNumbers, copyable, filename, className, children, ...props }: CodeProps): react_jsx_runtime.JSX.Element;
+
+type LinkUnderline = 'always' | 'hover' | 'none';
+interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    external?: boolean;
+    underline?: LinkUnderline;
+    color?: 'primary' | 'text' | 'muted' | 'inherit';
+    showExternalIcon?: boolean;
+}
+declare function Link({ external, underline, color, showExternalIcon, className, children, target, rel, ...props }: LinkProps): react_jsx_runtime.JSX.Element;
+
+type KbdSize = 'sm' | 'md' | 'lg';
+interface KbdProps {
+    children: React.ReactNode;
+    size?: KbdSize;
+    className?: string;
+}
+declare function Kbd({ children, size, className }: KbdProps): react_jsx_runtime.JSX.Element;
+
+type CopyButtonSize = 'sm' | 'md' | 'lg';
+type CopyButtonVariant = 'ghost' | 'outline' | 'solid';
+interface CopyButtonProps {
+    value: string;
+    size?: CopyButtonSize;
+    variant?: CopyButtonVariant;
+    label?: string;
+    copiedLabel?: string;
+    timeout?: number;
+    onCopy?: (value: string) => void;
+    className?: string;
+    disabled?: boolean;
+}
+declare function CopyButton({ value, size, variant, label, copiedLabel, timeout, onCopy, className, disabled, }: CopyButtonProps): react_jsx_runtime.JSX.Element;
+
+export { Alert, AppShell, ArrayValidator, Avatar, AvatarGroup, Badge, BadgeAnchor, BooleanValidator, Box, Breadcrumb, Button, Card, Checkbox, ChipSelect, Code, Collapsible, CommandPalette, ConfirmDialog, ConfirmDialogProvider, Container, ContextMenu, CopyButton, DEFAULT_COUNTRY_CODES, DataTable, DatePicker, DateValidator, Divider, Drawer, EmailValidator, EmptyState, ErrorBoundary, FileUpload, FileValidator, FormField, FullScreenLoader, FullScreenLoaderProvider, Grid, Heading, Icon, IconButton, Image, JSONForm, Kbd, Label, Link, List, ListItem, MarkdownReader, Modal, MultiSelect, Navbar, NumberInput, NumberValidator, OTPInput, Pagination, PasswordValidator, PhoneInput, Popover, ProgressBar, RadioGroup, Rating, SVG, SearchSelect, Select, SelectValidator, Sidebar, Skeleton, SkeletonCard, Slider, Spacer, Spinner, Stack, Stat, StepIndicator, StringValidator, Switch, Table, Tabs, TabsContent, Tag, TagInput, TelValidator, Text, TextArea, TextField, ThemeProvider, Timeline, ToastProvider, Tooltip, TreeView, UrlValidator, buttonVariants, cn, useClickOutside, useClipboard, useCommandPalette, useConfirm, useDebounce, useFullScreenLoader, useIntersectionObserver, useKeyboard, useLocalStorage, useMediaQuery, useTheme, useToast, useWindowSize, v };
+export type { AlertProps, AnyValidator, AppShellProps, AvatarGroupProps, AvatarProps, AvatarSize, AvatarStatus, BadgeAnchorProps, BadgeProps, BoxProps, BreadcrumbItem, BreadcrumbProps, ButtonProps, CardProps, CheckboxProps, ChipSelectOption, ChipSelectProps, ChipSelectSize, CodeProps, CodeTheme, CollapsibleProps, CommandGroup, CommandItem, CommandPaletteProps, CompiledRules, ConfirmDialogProps, ConfirmDialogProviderProps, ConfirmOptions, ConfirmVariant, ContainerProps, ContainerSize, ContextMenuItem, ContextMenuProps, CopyButtonProps, CopyButtonSize, CopyButtonVariant, CountryCode, DataTableColumn, DataTablePagination, DataTableProps, DatePickerMode, DatePickerProps, DatePickerRangeProps, DatePickerSingleProps, DatePickerSize, DividerProps, DrawerProps, DrawerSide, DrawerSize, EmptyStateProps, ErrorBoundaryProps, FileUploadProps, FormFieldProps, FullScreenLoaderControls, FullScreenLoaderProps, FullScreenLoaderProviderProps, FullScreenLoaderState, GridCols, GridGap, GridProps, HeadingLevel, HeadingProps, HeadingSize, HeadingWeight, IconButtonProps, IconProps, IconSize, ImageFit, ImageProps, ImageRatio, JSONFieldType, JSONFormField, JSONFormOption, JSONFormProps, KbdProps, KbdSize, KeyboardModifier, KeyboardShortcut, LabelProps, LinkProps, LinkUnderline, ListItemProps, ListProps, MarkdownReaderProps, ModalProps, ModalSize, MultiSelectGroup, MultiSelectOption, MultiSelectProps, NavbarLink, NavbarProps, NumberInputProps, NumberInputSize, OTPInputProps, OTPInputSize, PaginationProps, PhoneInputProps, PhoneInputSize, PhoneInputValue, PopoverPlacement, PopoverProps, ProgressBarProps, ProgressSize, ProgressVariant, RadioGroupProps, RadioOption, RatingProps, RatingSize, SVGProps, SearchSelectGroup, SearchSelectMultiProps, SearchSelectOption, SearchSelectProps, SearchSelectSingleProps, SelectGroup, SelectOption, SelectProps, SidebarItem, SidebarProps, SkeletonCardProps, SkeletonProps, SkeletonVariant, SliderProps, SliderSize, SortDirection$1 as SortDirection, SpacerProps, SpinnerProps, SpinnerSize, StackAlign, StackDirection, StackGap, StackJustify, StackProps, StatProps, Step, StepIndicatorProps, StepStatus, SwitchProps, TabItem, TableColumn, TableProps, TabsProps, TabsVariant, TagInputProps, TagProps, TagSeparator, TextAreaProps, TextAs, TextColor, TextFieldProps, TextFieldSize, TextProps, TextSize, TextWeight, ThemeProviderProps, ThemeTokens, TimelineItem, TimelineProps, Toast, ToastPosition, ToastProviderProps, ToastVariant, TooltipPlacement, TooltipProps, TreeViewItem, TreeViewProps, UploadedFile, UseClipboardOptions, UseClipboardReturn, UseIntersectionObserverOptions, UseToastReturn, WindowSize };