@class-kit/react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1032 @@
+import React from "react";
+import { FormController, ChatVirtualListController, ComicReaderController, AffixController, BacktopController, BadgeController, BreadcrumbController, CalendarController, CanvasEditorController, CanvasImageController, ColorPickerController, CountdownController, DanmakuController, DatePickerController, DateRangePickerController, DragController, DropController, FloatingBallController, FilePreviewController, GestureController, DesignEffectController, GradientTextController, LazyImageController, LiveRoomController, MasonryVirtualListController, MultiColumnPickerController, ModalController, PasswordInputController, PopupController, ProgressController, SignatureController, SlideCaptchaController, PaginationController, SkeletonController, NovelReaderController, SwiperController, TableController, TabsController, TagController, TiltCardController, TimelineController, TooltipController, ToastManager, TypewriterTextController, UploadController, VerificationCodeController, VideoDetailTransitionController, VideoPlayerController, VirtualSelectController, VirtualListController, getClassComponentsLocale } from "@class-kit/core";
+import type { FieldOptions, FieldPath, ComicPage, DanmakuItem, DropItem, DragPosition, FormOptions, FormState, FormValues, CanvasEditorMode, CanvasEditorNode, CanvasEditorState, CanvasImageLayer, CanvasImageState, FilePreviewState, FilePreviewType, DesignEffectOptions, GradientTextOptions, LiveChatMessage, LiveHostInfo, DateRangeValue, CountdownFormat, BreadcrumbItem, LazyImageStatus, MarqueeDirection, MarqueeItem, MarqueeItemInput, MarqueeStepAnimation, MarqueeVerticalMode, NovelReaderPage, MultiColumnPickerDateSource, PopupPlacement, PickerOption, TabItem, TimelineItem, TableColumn, UploadFileItem, TiltCardOptions, ToastItem, ToastPosition, SignatureState, SignatureStroke, TypewriterTextOptions, VideoDetailItem, VideoPlayerSourceInput, VirtualItem, MasonryVirtualItem, SlideCaptchaState, TooltipPlacement, TooltipTrigger, VerificationCodeState, ClassComponentsLocale, ClassKitThemeInput } from "@class-kit/core";
+export declare const defaultToastManager: ToastManager;
+export interface ClassConfigProviderProps {
+    children?: React.ReactNode;
+    className?: string;
+    locale?: Partial<ClassComponentsLocale>;
+    style?: React.CSSProperties;
+    theme?: ClassKitThemeInput;
+}
+export declare function ClassConfigProvider({ children, className, locale, style, theme, }: ClassConfigProviderProps): React.ReactElement;
+export interface ChoiceOption<Value extends string | number = string> {
+    label: React.ReactNode;
+    value: Value;
+    disabled?: boolean;
+}
+interface StyleSlots {
+    className?: string;
+    labelClassName?: string;
+    controlClassName?: string;
+    errorClassName?: string;
+}
+export type AnimationState = "enter" | "exit";
+export type AnimationName = "fade" | "scale" | "slide" | "none";
+export type TabsAnimationDirection = "auto" | "forward" | "backward" | "none";
+export interface AnimationOptions {
+    enabled?: boolean;
+    name?: AnimationName;
+    duration?: number;
+    easing?: string;
+}
+export interface TabsAnimationOptions extends AnimationOptions {
+    direction?: TabsAnimationDirection;
+}
+export interface FormProviderProps<Values extends FormValues = FormValues> extends FormOptions<Values>, Omit<React.FormHTMLAttributes<HTMLFormElement>, "children" | "className" | "onSubmit"> {
+    form?: FormController<Values>;
+    children: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+export declare function FormProvider<Values extends FormValues = FormValues>({ form, children, className, disabled, readOnly, onReset, ...options }: FormProviderProps<Values>): React.ReactElement;
+export declare function useForm<Values extends FormValues = FormValues>(): FormController<Values>;
+export declare function useFormState<Values extends FormValues = FormValues>(): FormState<Values>;
+export interface UseFieldResult<Value = unknown> {
+    value: Value;
+    errors: string[];
+    dirty: boolean;
+    touched: boolean;
+    setValue: (value: Value) => void;
+    onBlur: () => void;
+}
+export declare function useField<Value = unknown, Values extends FormValues = FormValues>(name: FieldPath, options?: FieldOptions<Values>): UseFieldResult<Value>;
+export interface FieldProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, StyleSlots, Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "defaultValue" | "name" | "onBlur" | "onChange" | "type" | "value"> {
+    name?: FieldPath;
+    label?: string;
+    type?: React.HTMLInputTypeAttribute;
+    clearable?: boolean;
+    clearIcon?: React.ReactNode;
+    clearLabel?: string;
+    controlWrapClassName?: string;
+}
+export declare function Input<Values extends FormValues = FormValues>({ name, label, type, className, labelClassName, controlClassName, controlWrapClassName, errorClassName, clearable, clearIcon, clearLabel, disabled, readOnly, initialValue, rules, validateOn, ...options }: FieldProps<Values>): React.ReactElement;
+export interface PasswordInputProps<Values extends FormValues = FormValues> extends Omit<FieldProps<Values>, "type"> {
+    defaultVisible?: boolean;
+    hiddenIcon?: React.ReactNode;
+    hiddenImage?: string | {
+        alt?: string;
+        src: string;
+    };
+    onVisibleChange?: (visible: boolean) => void;
+    showToggle?: boolean;
+    toggleLabel?: string;
+    toggleType?: "icon" | "image" | "text";
+    visible?: boolean;
+    visibleIcon?: React.ReactNode;
+    visibleImage?: string | {
+        alt?: string;
+        src: string;
+    };
+}
+export declare function PasswordInput<Values extends FormValues = FormValues>({ name, label, className, labelClassName, controlClassName, controlWrapClassName, errorClassName, clearable, clearIcon, clearLabel, defaultVisible, disabled, hiddenIcon, hiddenImage, initialValue, onVisibleChange, readOnly, rules, showToggle, toggleLabel, toggleType, validateOn, visible, visibleIcon, visibleImage, ...options }: PasswordInputProps<Values>): React.ReactElement;
+export declare const Field: typeof Input;
+export interface ColorPickerProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    name?: FieldPath;
+    label?: React.ReactNode;
+    disabled?: boolean;
+    readOnly?: boolean;
+    panelClassName?: string;
+    showInputSteppers?: boolean;
+    onChange?: (value: string) => void;
+}
+export declare function ColorPicker<Values extends FormValues = FormValues>({ name, label, className, disabled, panelClassName, readOnly, initialValue, rules, showInputSteppers, validateOn, onChange, ...props }: ColorPickerProps<Values>): React.ReactElement;
+export interface DatePickerProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    name?: FieldPath;
+    label?: React.ReactNode;
+    limitDate?: string;
+    limitDirection?: "after" | "before";
+    max?: string;
+    min?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    placeholder?: string;
+    previousMonthIcon?: React.ReactNode;
+    nextMonthIcon?: React.ReactNode;
+    onChange?: (value: string) => void;
+}
+export declare function DatePicker<Values extends FormValues = FormValues>({ name, label, limitDate, limitDirection, max, min, className, disabled, readOnly, previousMonthIcon, nextMonthIcon, initialValue, placeholder, rules, validateOn, onChange, ...props }: DatePickerProps<Values>): React.ReactElement;
+export interface DateRangePickerProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    name?: FieldPath;
+    label?: React.ReactNode;
+    limitDate?: string;
+    limitDirection?: "after" | "before";
+    max?: string;
+    min?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    allowSameDay?: boolean;
+    placeholder?: string;
+    previousMonthIcon?: React.ReactNode;
+    nextMonthIcon?: React.ReactNode;
+    separator?: React.ReactNode;
+    onChange?: (value: DateRangeValue) => void;
+}
+export declare function DateRangePicker<Values extends FormValues = FormValues>({ name, label, limitDate, limitDirection, max, min, className, disabled, readOnly, allowSameDay, previousMonthIcon, nextMonthIcon, initialValue, placeholder, rules, separator, validateOn, onChange, ...props }: DateRangePickerProps<Values>): React.ReactElement;
+export interface VerificationCodeProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    name?: FieldPath;
+    length?: number;
+    label?: React.ReactNode;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    inputMode?: React.HTMLAttributes<HTMLInputElement>["inputMode"];
+    readOnly?: boolean;
+    onChange?: (value: string, state: VerificationCodeState) => void;
+    onComplete?: (value: string) => void;
+}
+export declare function VerificationCode<Values extends FormValues = FormValues>({ name, length, label, autoFocus, className, disabled, inputMode, readOnly, initialValue, rules, validateOn, onChange, onComplete, ...props }: VerificationCodeProps<Values>): React.ReactElement;
+export interface SlideCaptchaProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    name?: FieldPath;
+    backgroundAlt?: string;
+    backgroundImage: string;
+    disabled?: boolean;
+    height?: number;
+    label?: React.ReactNode;
+    moveAxis?: "x" | "xy";
+    pieceAlt?: string;
+    pieceHeight?: number;
+    pieceImage: string;
+    pieceTop?: number;
+    pieceWidth?: number;
+    readOnly?: boolean;
+    resetText?: React.ReactNode;
+    sliderText?: React.ReactNode;
+    successText?: React.ReactNode;
+    targetX?: number;
+    targetY?: number;
+    thumbIcon?: React.ReactNode;
+    tolerance?: number;
+    trackText?: React.ReactNode;
+    width?: number;
+    onChange?: (value: boolean, state: SlideCaptchaState) => void;
+    onFail?: (state: SlideCaptchaState) => void;
+    onSuccess?: (state: SlideCaptchaState) => void;
+}
+export declare function SlideCaptcha<Values extends FormValues = FormValues>({ name, backgroundAlt, backgroundImage, className, disabled, height, initialValue, label, moveAxis, pieceAlt, pieceHeight, pieceImage, pieceTop, pieceWidth, readOnly, resetText, rules, sliderText, successText, targetX, targetY, thumbIcon, tolerance, trackText, validateOn, width, onChange, onFail, onSuccess, ...props }: SlideCaptchaProps<Values>): React.ReactElement;
+export interface NumberInputProps<Values extends FormValues = FormValues> extends Omit<FieldProps<Values>, "type"> {
+}
+export declare function NumberInput<Values extends FormValues = FormValues>({ name, label, className, labelClassName, controlClassName, controlWrapClassName, errorClassName, clearable, clearIcon, clearLabel, disabled, readOnly, initialValue, max, min, rules, step, validateOn, ...options }: NumberInputProps<Values>): React.ReactElement;
+export interface TextareaProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, StyleSlots, Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "className" | "defaultValue" | "name" | "onBlur" | "onChange" | "value"> {
+    name?: FieldPath;
+    label?: string;
+    clearable?: boolean;
+    clearIcon?: React.ReactNode;
+    clearLabel?: string;
+    controlWrapClassName?: string;
+}
+export declare function Textarea<Values extends FormValues = FormValues>({ name, label, className, labelClassName, controlClassName, controlWrapClassName, errorClassName, clearable, clearIcon, clearLabel, disabled, readOnly, initialValue, rules, validateOn, rows, ...options }: TextareaProps<Values>): React.ReactElement;
+export interface SelectProps<Value extends string | number = string, Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "defaultValue" | "onChange"> {
+    name?: FieldPath;
+    label?: string;
+    placeholder?: string;
+    options: Array<ChoiceOption<Value>>;
+    disabled?: boolean;
+    readOnly?: boolean;
+    multiple?: boolean;
+    clearable?: boolean;
+    clearIcon?: React.ReactNode;
+    clearLabel?: string;
+    selectedIcon?: React.ReactNode;
+    onValueChange?: (value: Value | Value[] | "") => void;
+    menuRadius?: number | string;
+    menuBackground?: string;
+    menuBorderColor?: string;
+    menuTextColor?: string;
+    optionHoverColor?: string;
+    optionSelectedColor?: string;
+    className?: string;
+    labelClassName?: string;
+    controlClassName?: string;
+    menuClassName?: string;
+    optionClassName?: string;
+    selectedIconClassName?: string;
+    errorClassName?: string;
+}
+export declare function Select<Value extends string | number = string, Values extends FormValues = FormValues>({ name, label, placeholder, options: selectOptions, className, labelClassName, controlClassName, menuClassName, optionClassName, selectedIconClassName, errorClassName, disabled, readOnly, multiple, clearable, clearIcon, clearLabel, selectedIcon, onValueChange, menuRadius, menuBackground, menuBorderColor, menuTextColor, optionHoverColor, optionSelectedColor, initialValue, rules, validateOn, id, style, ...props }: SelectProps<Value, Values>): React.ReactElement;
+export interface VirtualSelectProps<Value extends string | number = string, Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "defaultValue" | "onChange"> {
+    name?: FieldPath;
+    label?: string;
+    placeholder?: string;
+    options: Array<ChoiceOption<Value>>;
+    disabled?: boolean;
+    readOnly?: boolean;
+    multiple?: boolean;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    selectedIcon?: React.ReactNode;
+    clearable?: boolean;
+    clearIcon?: React.ReactNode;
+    clearLabel?: string;
+    itemHeight?: number;
+    menuHeight?: number;
+    overscan?: number;
+    onValueChange?: (value: Value | Value[] | "") => void;
+    className?: string;
+    labelClassName?: string;
+    rootClassName?: string;
+    controlClassName?: string;
+    menuClassName?: string;
+    searchClassName?: string;
+    viewportClassName?: string;
+    optionClassName?: string;
+    selectedIconClassName?: string;
+    errorClassName?: string;
+}
+export declare function VirtualSelect<Value extends string | number = string, Values extends FormValues = FormValues>({ name, label, placeholder, options, className, labelClassName, rootClassName, controlClassName, menuClassName, searchClassName, viewportClassName, optionClassName, selectedIconClassName, errorClassName, disabled, readOnly, multiple, searchable, searchPlaceholder, selectedIcon, clearable, clearIcon, clearLabel, itemHeight, menuHeight, overscan, onValueChange, initialValue, rules, validateOn, id, style, ...props }: VirtualSelectProps<Value, Values>): React.ReactElement;
+export interface RadioGroupProps<Value extends string | number = string, Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, "className" | "name" | "onChange"> {
+    name?: FieldPath;
+    label?: string;
+    options: Array<ChoiceOption<Value>>;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    labelClassName?: string;
+    itemClassName?: string;
+    itemsClassName?: string;
+    errorClassName?: string;
+}
+export declare function RadioGroup<Value extends string | number = string, Values extends FormValues = FormValues>({ name, label, options: radioOptions, disabled, readOnly, className, labelClassName, itemClassName, itemsClassName, errorClassName, initialValue, rules, validateOn, ...options }: RadioGroupProps<Value, Values>): React.ReactElement;
+export interface CheckboxProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.InputHTMLAttributes<HTMLInputElement>, "checked" | "className" | "defaultChecked" | "name" | "onBlur" | "onChange" | "type"> {
+    name?: FieldPath;
+    label: React.ReactNode;
+    className?: string;
+    labelClassName?: string;
+    errorClassName?: string;
+}
+export declare function Checkbox<Values extends FormValues = FormValues>({ name, label, className, labelClassName, errorClassName, disabled, readOnly, initialValue, rules, validateOn, ...options }: CheckboxProps<Values>): React.ReactElement;
+export declare const Checked: typeof Checkbox;
+export interface SwitchProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.InputHTMLAttributes<HTMLInputElement>, "checked" | "className" | "defaultChecked" | "name" | "onBlur" | "onChange" | "type"> {
+    name?: FieldPath;
+    label?: React.ReactNode;
+    className?: string;
+    labelClassName?: string;
+    switchClassName?: string;
+    trackClassName?: string;
+    thumbClassName?: string;
+    errorClassName?: string;
+}
+export declare function Switch<Values extends FormValues = FormValues>({ name, label, className, labelClassName, switchClassName, trackClassName, thumbClassName, errorClassName, disabled, readOnly, initialValue, rules, validateOn, ...options }: SwitchProps<Values>): React.ReactElement;
+export interface RatingProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, "className" | "defaultValue" | "name" | "onChange"> {
+    name?: FieldPath;
+    label?: string;
+    max?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    labelClassName?: string;
+    starsClassName?: string;
+    starClassName?: string;
+    errorClassName?: string;
+    starLabel?: (value: number) => string;
+    icon?: React.ReactNode | ((context: {
+        active: boolean;
+        value: number;
+    }) => React.ReactNode);
+}
+export declare function Rating<Values extends FormValues = FormValues>({ name, label, max, disabled, readOnly, className, labelClassName, starsClassName, starClassName, errorClassName, starLabel, icon, initialValue, rules, validateOn, ...options }: RatingProps<Values>): React.ReactElement;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: "primary" | "secondary" | "ghost" | "danger" | "soft" | "shine" | "neon";
+    loading?: boolean;
+}
+export declare function Button({ children, className, disabled, loading, type, variant, ...props }: ButtonProps): React.ReactElement;
+export interface LoadingProps extends React.HTMLAttributes<HTMLDivElement> {
+    indicator?: React.ReactNode;
+    text?: React.ReactNode;
+}
+export declare function Loading({ className, indicator, text, ...props }: LoadingProps): React.ReactElement;
+export interface EmptyProps extends React.HTMLAttributes<HTMLDivElement> {
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+}
+export declare function Empty({ className, description, icon, ...props }: EmptyProps): React.ReactElement;
+export interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    dot?: boolean;
+    max?: number;
+    tone?: "danger" | "info" | "neutral" | "success" | "warning";
+    value?: number | string;
+}
+export declare function Badge({ children, className, dot, max, tone, value, ...props }: BadgeProps): React.ReactElement;
+export interface TagProps extends React.HTMLAttributes<HTMLSpanElement> {
+    checkable?: boolean;
+    checked?: boolean;
+    closable?: boolean;
+    disabled?: boolean;
+    shape?: "pill" | "round" | "square";
+    size?: "large" | "medium" | "small";
+    tone?: "danger" | "info" | "neutral" | "success" | "warning";
+    variant?: "filled" | "outline" | "soft";
+    closeIcon?: React.ReactNode;
+    onClose?: () => void;
+    onCheckedChange?: (checked: boolean) => void;
+}
+export declare function Tag({ children, className, checkable, checked, closable, disabled, shape, size, tone, variant, closeIcon, onClose, onCheckedChange, ...props }: TagProps): React.ReactElement | null;
+export interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    animated?: boolean;
+    count?: number;
+    loading?: boolean;
+}
+export declare function Skeleton({ animated, children, className, count, loading, ...props }: SkeletonProps): React.ReactElement;
+export interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
+    items: BreadcrumbItem[];
+    separator?: React.ReactNode;
+}
+export declare function Breadcrumb({ className, items, separator, ...props }: BreadcrumbProps): React.ReactElement;
+export interface PaginationProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    boundaryCount?: number;
+    current?: number;
+    pageSize?: number;
+    siblingCount?: number;
+    total?: number;
+    previousIcon?: React.ReactNode;
+    nextIcon?: React.ReactNode;
+    onChange?: (page: number) => void;
+}
+export declare function Pagination({ boundaryCount, className, current, pageSize, siblingCount, total, previousIcon, nextIcon, onChange, ...props }: PaginationProps): React.ReactElement;
+export interface PopconfirmProps {
+    children: React.ReactNode;
+    animation?: AnimationOptions | false;
+    autoAdjust?: boolean;
+    placement?: TooltipPlacement;
+    content?: React.ReactNode;
+    confirmText?: React.ReactNode;
+    cancelText?: React.ReactNode;
+    closeOnEsc?: boolean;
+    closeOnOutsideClick?: boolean;
+    onConfirm?: () => void;
+}
+export declare function Popconfirm({ children, animation, autoAdjust, placement, content, confirmText, cancelText, closeOnEsc, closeOnOutsideClick, onConfirm, }: PopconfirmProps): React.ReactElement;
+export interface BacktopProps extends React.HTMLAttributes<HTMLButtonElement> {
+    duration?: number;
+    target?: string | (() => HTMLElement | Window | null | undefined);
+    visibilityHeight?: number;
+}
+export declare function Backtop({ className, duration, target, visibilityHeight, children, onClick, ...props }: BacktopProps): React.ReactElement | null;
+export interface AffixProps extends React.HTMLAttributes<HTMLDivElement> {
+    offsetTop?: number;
+    target?: string | (() => HTMLElement | Window | null | undefined);
+}
+export declare function Affix({ children, className, offsetTop, style, target, ...props }: AffixProps): React.ReactElement;
+export interface ModalProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    open?: boolean;
+    controller?: ModalController;
+    title?: React.ReactNode;
+    children: React.ReactNode;
+    animation?: AnimationOptions | false;
+    allowPageScroll?: boolean;
+    closeOnEsc?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeIcon?: React.ReactNode;
+    containerRef?: React.RefObject<HTMLElement>;
+    lockScroll?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    panelClassName?: string;
+    pushDistance?: number | string;
+    pushTargetRef?: React.RefObject<HTMLElement>;
+    restoreFocus?: boolean;
+    trapFocus?: boolean;
+    overlayClassName?: string;
+}
+export declare function Modal({ open, controller, title, children, animation, allowPageScroll, closeOnEsc, closeOnOverlayClick, closeIcon, containerRef, lockScroll, className, panelClassName, overlayClassName, restoreFocus, style, trapFocus, onOpenChange, ...props }: ModalProps): React.ReactElement | null;
+export interface PopupProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    open?: boolean;
+    controller?: PopupController;
+    placement?: PopupPlacement;
+    title?: React.ReactNode;
+    children: React.ReactNode;
+    animation?: AnimationOptions | false;
+    allowPageScroll?: boolean;
+    closeOnEsc?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeIcon?: React.ReactNode;
+    containerRef?: React.RefObject<HTMLElement>;
+    lockScroll?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    panelClassName?: string;
+    pushDistance?: number | string;
+    pushTargetRef?: React.RefObject<HTMLElement>;
+    restoreFocus?: boolean;
+    trapFocus?: boolean;
+    overlayClassName?: string;
+}
+export declare function Popup({ open, controller, placement, title, children, animation, allowPageScroll, closeOnEsc, closeOnOverlayClick, closeIcon, containerRef, lockScroll, className, panelClassName, overlayClassName, pushDistance, pushTargetRef, restoreFocus, style, trapFocus, onOpenChange, ...props }: PopupProps): React.ReactElement | null;
+export interface TooltipProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "content"> {
+    content: React.ReactNode;
+    children: React.ReactNode;
+    animation?: AnimationOptions | false;
+    placement?: TooltipPlacement;
+    trigger?: TooltipTrigger;
+    autoAdjust?: boolean;
+    closeOnEsc?: boolean;
+    closeOnOutsideClick?: boolean;
+}
+export declare function Tooltip({ content, children, animation, placement, trigger, autoAdjust, closeOnEsc, closeOnOutsideClick, className, id, style, ...props }: TooltipProps): React.ReactElement;
+export interface ToastViewportProps extends React.HTMLAttributes<HTMLDivElement> {
+    animation?: AnimationOptions | false;
+    manager?: ToastManager;
+    position?: ToastPosition;
+    renderToast?: (toast: ToastItem, dismiss: (id: string) => void, state: AnimationState) => React.ReactNode;
+}
+export declare function ToastViewport({ animation, manager, className, position, renderToast, style, ...props }: ToastViewportProps): React.ReactElement;
+export interface TabsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    tabs: TabItem[];
+    animation?: TabsAnimationOptions | false;
+    activeId?: string;
+    controller?: TabsController;
+    children: (activeId: string) => React.ReactNode;
+    cachePanels?: boolean;
+    emptyTabs?: string[] | Record<string, boolean> | ((activeId: string) => boolean);
+    loadingTabs?: string[] | Record<string, boolean> | ((activeId: string) => boolean);
+    onActiveChange?: (activeId: string) => void;
+    orientation?: "horizontal" | "vertical";
+    panelClassName?: string;
+    renderEmpty?: (activeId: string) => React.ReactNode;
+    renderLoading?: (activeId: string) => React.ReactNode;
+}
+export declare function Tabs({ tabs, animation, activeId, controller, children, cachePanels, className, emptyTabs, loadingTabs, orientation, panelClassName, renderEmpty, renderLoading, style, onActiveChange, ...props }: TabsProps): React.ReactElement;
+export interface RollingNumberProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+    value: number;
+    minDigits?: number;
+    duration?: number;
+    digitClassName?: string;
+    trackClassName?: string;
+    numberClassName?: string;
+}
+export declare function RollingNumber({ value, minDigits, duration, className, digitClassName, trackClassName, numberClassName, style, ...props }: RollingNumberProps): React.ReactElement;
+export interface CountdownProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "onChange"> {
+    autoStart?: boolean;
+    duration?: number;
+    format?: CountdownFormat;
+    interval?: number;
+    minutes?: number;
+    seconds?: number;
+    target?: Date | number | string;
+    onComplete?: () => void;
+    render?: (state: ReturnType<CountdownController["getState"]>) => React.ReactNode;
+}
+export declare function Countdown({ autoStart, className, duration, format, interval, minutes, seconds, target, onComplete, render, ...props }: CountdownProps): React.ReactElement;
+export interface CalendarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    max?: string;
+    min?: string;
+    disabled?: boolean;
+    festivals?: Record<string, React.ReactNode>;
+    previousMonthIcon?: React.ReactNode;
+    nextMonthIcon?: React.ReactNode;
+    onChange?: (value: string) => void;
+}
+export declare function Calendar({ value, defaultValue, max, min, disabled, festivals, previousMonthIcon, nextMonthIcon, className, onChange, ...props }: CalendarProps): React.ReactElement;
+export interface TypewriterTextProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children">, TypewriterTextOptions {
+    cursorClassName?: string;
+    loadingClassName?: string;
+    loadingNode?: React.ReactNode;
+    text: string;
+}
+export declare function TypewriterText({ text, cursor, cursorClassName, delay, disabled, loading, loadingClassName, loadingNode, loop, speed, startOnMount, className, "aria-label": ariaLabel, ...props }: TypewriterTextProps): React.ReactElement;
+export interface DesignEffectProps extends DesignEffectOptions, Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "className"> {
+    children?: React.ReactNode;
+    className?: string;
+    contentClassName?: string;
+    overlayClassName?: string;
+}
+export declare function DesignEffect({ animated, children, className, colors, contentClassName, disabled, intensity, interactive, overlayClassName, preset, radius, style, tone, ...props }: DesignEffectProps): React.ReactElement;
+export interface GradientTextProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children">, GradientTextOptions {
+    children?: React.ReactNode;
+}
+export declare function GradientText({ animated, backgroundSize, children, className, colors, direction, duration, easing, fontWeight, style, text, ...props }: GradientTextProps): React.ReactElement;
+export interface QRCodeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+    value: string;
+    size?: number;
+    margin?: number;
+    darkColor?: string;
+    lightColor?: string;
+    errorCorrectionLevel?: "L" | "M" | "Q" | "H";
+    errorText?: React.ReactNode;
+    logoSrc?: string;
+    logoAlt?: string;
+    logoSize?: number;
+    logoPadding?: number;
+    logoRadius?: number;
+    logoBackground?: string;
+    renderError?: (error: Error) => React.ReactNode;
+}
+export interface LazyImageRenderState {
+    status: LazyImageStatus;
+}
+export type LazyImageLoadingVariant = "image" | "none" | "skeleton";
+export interface LazyImageProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onLoad" | "onError"> {
+    src: string;
+    alt?: string;
+    eager?: boolean;
+    fallbackSrc?: string;
+    placeholderSrc?: string;
+    rootMargin?: string;
+    threshold?: number;
+    width?: number | string;
+    height?: number | string;
+    aspectRatio?: number | string;
+    objectFit?: React.CSSProperties["objectFit"];
+    loadingVariant?: LazyImageLoadingVariant;
+    imageClassName?: string;
+    placeholderClassName?: string;
+    skeletonClassName?: string;
+    errorClassName?: string;
+    imageProps?: Omit<React.ImgHTMLAttributes<HTMLImageElement>, "src" | "alt" | "onLoad" | "onError">;
+    renderPlaceholder?: (state: LazyImageRenderState) => React.ReactNode;
+    renderError?: (state: LazyImageRenderState) => React.ReactNode;
+    onLoad?: React.ReactEventHandler<HTMLImageElement>;
+    onError?: React.ReactEventHandler<HTMLImageElement>;
+}
+export declare function LazyImage({ src, alt, eager, fallbackSrc, placeholderSrc, rootMargin, threshold, width, height, aspectRatio, objectFit, loadingVariant, className, imageClassName, placeholderClassName, skeletonClassName, errorClassName, imageProps, renderPlaceholder, renderError, onLoad, onError, style, ...props }: LazyImageProps): React.ReactElement;
+export interface TiltCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onPointerEnter" | "onPointerMove" | "onPointerLeave">, TiltCardOptions {
+    contentClassName?: string;
+    glareClassName?: string;
+    onPointerEnter?: React.PointerEventHandler<HTMLDivElement>;
+    onPointerLeave?: React.PointerEventHandler<HTMLDivElement>;
+    onPointerMove?: React.PointerEventHandler<HTMLDivElement>;
+    surfaceClassName?: string;
+}
+export declare function TiltCard({ children, className, contentClassName, disabled, enterTransitionDuration, glare, glareClassName, maxTilt, moveTransitionDuration, perspective, scale, onPointerEnter, onPointerLeave, onPointerMove, style, surfaceClassName, transitionDuration, transitionEasing, ...props }: TiltCardProps): React.ReactElement;
+export declare function QRCode({ value, size, margin, darkColor, lightColor, className, errorCorrectionLevel, errorText, logoSrc, logoAlt, logoSize, logoPadding, logoRadius, logoBackground, renderError, ...props }: QRCodeProps): React.ReactElement;
+export interface BarcodeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+    value: string;
+    format?: string;
+    width?: number;
+    height?: number;
+    lineColor?: string;
+    background?: string;
+    displayValue?: boolean;
+    errorText?: React.ReactNode;
+    fontSize?: number;
+    margin?: number;
+    renderError?: (error: Error) => React.ReactNode;
+}
+export declare function Barcode({ value, format, width, height, lineColor, background, displayValue, errorText, fontSize, margin, className, renderError, ...props }: BarcodeProps): React.ReactElement;
+export interface EllipsisTextProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    text: React.ReactNode;
+    lines?: number;
+    defaultExpanded?: boolean;
+    expandable?: boolean;
+    expanded?: boolean;
+    expandedMaxHeight?: number | string;
+    backgroundColor?: string;
+    textColor?: string;
+    transitionDuration?: number | string;
+    contentClassName?: string;
+    onExpandedChange?: (expanded: boolean) => void;
+}
+export declare function EllipsisText({ text, lines, defaultExpanded, expandable, expanded, expandedMaxHeight, backgroundColor, textColor, transitionDuration, className, contentClassName, onClick, onKeyDown, onExpandedChange, role, style, tabIndex, ...props }: EllipsisTextProps): React.ReactElement;
+export interface MarqueeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    items: readonly MarqueeItemInput[];
+    direction?: MarqueeDirection;
+    duration?: number;
+    gap?: number | string;
+    itemHeight?: number | string;
+    pauseOnHover?: boolean;
+    reverse?: boolean;
+    stepAnimation?: MarqueeStepAnimation;
+    stepAnimationDuration?: number;
+    verticalMode?: MarqueeVerticalMode;
+    ariaLabel?: string;
+    contentClassName?: string;
+    groupClassName?: string;
+    itemClassName?: string;
+    onItemClick?: (item: MarqueeItem, index: number, event: React.MouseEvent<HTMLSpanElement> | React.KeyboardEvent<HTMLSpanElement>) => void;
+    renderItem?: (item: MarqueeItem, index: number) => React.ReactNode;
+    trackClassName?: string;
+}
+export declare function Marquee({ items, direction, duration, gap, itemHeight, pauseOnHover, reverse, stepAnimation, stepAnimationDuration, verticalMode, ariaLabel, className, contentClassName, groupClassName, itemClassName, onItemClick, renderItem, trackClassName, style, ...props }: MarqueeProps): React.ReactElement;
+export interface VideoPlayerProps extends Omit<React.VideoHTMLAttributes<HTMLVideoElement>, "children" | "preload" | "src"> {
+    autoplay?: boolean;
+    controls?: boolean;
+    preload?: "auto" | "metadata" | "none";
+    sources: VideoPlayerSourceInput | VideoPlayerSourceInput[];
+    containerClassName?: string;
+}
+export interface VideoDetailTransitionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> {
+    animationDuration?: number;
+    backdropColor?: string;
+    columns?: number;
+    closeIcon?: React.ReactNode;
+    container?: VideoDetailContainer;
+    detailClassName?: string;
+    gridClassName?: string;
+    itemClassName?: string;
+    items: VideoDetailItem[];
+    onClose?: () => void;
+    onOpen?: (item: VideoDetailItem) => void;
+}
+export type FilePreviewLocalRenderResult = React.ReactNode | string;
+export type FilePreviewLocalRenderer = (file: File, state: FilePreviewState) => FilePreviewLocalRenderResult | Promise<FilePreviewLocalRenderResult>;
+export interface FilePreviewProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    currentPage?: number;
+    file?: File;
+    fileName?: string;
+    height?: number | string;
+    localUnsupportedText?: React.ReactNode;
+    pageCount?: number;
+    renderLocalExcel?: FilePreviewLocalRenderer;
+    renderLocalPpt?: FilePreviewLocalRenderer;
+    renderLocalWord?: FilePreviewLocalRenderer;
+    src?: string;
+    title?: React.ReactNode;
+    type?: FilePreviewType;
+    viewerBaseUrl?: string;
+    onPageChange?: (page: number) => void;
+}
+export interface CanvasImageHandle {
+    render: () => Promise<CanvasImageState | null>;
+    toDataURL: (type?: string, quality?: number) => string;
+}
+export interface CanvasImageProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onError"> {
+    background?: string;
+    canvasClassName?: string;
+    dpr?: number;
+    height: number;
+    layers?: CanvasImageLayer[];
+    width: number;
+    onError?: (error: Error) => void;
+    onRendered?: (state: CanvasImageState) => void;
+}
+export interface CanvasEditorProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    defaultMode?: CanvasEditorMode;
+    defaultNodes?: CanvasEditorNode[];
+    disabled?: boolean;
+    mode?: CanvasEditorMode;
+    nodes?: CanvasEditorNode[];
+    readOnly?: boolean;
+    rootId?: string;
+    onModeChange?: (mode: CanvasEditorMode) => void;
+    onNodesChange?: (nodes: CanvasEditorNode[]) => void;
+    onStateChange?: (state: CanvasEditorState) => void;
+}
+export interface ProgressBarProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> {
+    defaultValue?: number;
+    disabled?: boolean;
+    errorClassName?: string;
+    fieldClassName?: string;
+    followPointer?: boolean;
+    interactive?: boolean;
+    label?: React.ReactNode;
+    labelClassName?: string;
+    max?: number;
+    min?: number;
+    name?: FieldPath;
+    readOnly?: boolean;
+    step?: number;
+    value?: number;
+    onChange?: (value: number) => void;
+    onChangeEnd?: (value: number) => void;
+}
+export declare function ProgressBar<Values extends FormValues = FormValues>({ defaultValue, disabled, errorClassName, fieldClassName, followPointer, initialValue, interactive, label, labelClassName, max, min, name, readOnly, rules, step, validateOn, value, className, onChange, onChangeEnd, ...props }: ProgressBarProps<Values>): React.ReactElement;
+export interface SignatureHandle {
+    clear: () => void;
+    isEmpty: () => boolean;
+    toDataURL: (type?: string, quality?: number) => string;
+    undo: () => void;
+}
+export interface SignatureProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> {
+    backgroundColor?: string;
+    canvasClassName?: string;
+    clearText?: React.ReactNode;
+    disabled?: boolean;
+    errorClassName?: string;
+    exportType?: string;
+    fieldClassName?: string;
+    height?: number | string;
+    initialValue?: SignatureState | SignatureStroke[];
+    label?: React.ReactNode;
+    labelClassName?: string;
+    lineWidth?: number;
+    name?: FieldPath;
+    penColor?: string;
+    readOnly?: boolean;
+    showToolbar?: boolean;
+    toolbarClassName?: string;
+    undoText?: React.ReactNode;
+    width?: number | string;
+    onChange?: (state: SignatureState) => void;
+    onClear?: () => void;
+    onEnd?: (state: SignatureState) => void;
+    onUndo?: (state: SignatureState) => void;
+}
+export declare const Signature: React.ForwardRefExoticComponent<SignatureProps<FormValues> & React.RefAttributes<SignatureHandle>>;
+export declare function VideoPlayer({ sources, autoplay, controls, loop, muted, poster, preload, className, containerClassName, ...props }: VideoPlayerProps): React.ReactElement;
+type VideoDetailContainer = HTMLElement | (() => HTMLElement | null) | React.RefObject<HTMLElement | null> | null | undefined;
+export declare function VideoDetailTransition({ animationDuration, backdropColor, className, closeIcon, columns, container, detailClassName, gridClassName, itemClassName, items, onClose, onOpen, style, ...props }: VideoDetailTransitionProps): React.ReactElement;
+export declare function FilePreview({ currentPage, file, fileName, height, localUnsupportedText, pageCount, renderLocalExcel, renderLocalPpt, renderLocalWord, src, title, type, viewerBaseUrl, className, onPageChange, style, ...props }: FilePreviewProps): React.ReactElement;
+export declare const CanvasImage: React.ForwardRefExoticComponent<CanvasImageProps & React.RefAttributes<CanvasImageHandle>>;
+export declare function CanvasEditor({ className, defaultMode, defaultNodes, disabled, mode, nodes, readOnly, rootId, style, onModeChange, onNodesChange, onStateChange, ...props }: CanvasEditorProps): React.ReactElement;
+export interface TimelineProps extends Omit<React.HTMLAttributes<HTMLOListElement>, "children"> {
+    direction?: "horizontal" | "vertical";
+    items: TimelineItem[];
+    renderItem?: (item: TimelineItem, index: number) => React.ReactNode;
+}
+export declare function Timeline({ direction, items, renderItem, className, ...props }: TimelineProps): React.ReactElement;
+export interface FloatingBallProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    adsorb?: boolean;
+    adsorbAxis?: "x" | "xy" | "y";
+    boundaryRef?: React.RefObject<HTMLElement>;
+    children: React.ReactNode;
+    gap?: number;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    moveAxis?: "x" | "xy" | "y";
+    onPositionChange?: (position: {
+        x: number;
+        y: number;
+    }) => void;
+}
+export interface DraggableProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onDrag" | "onDragEnd" | "onDragStart"> {
+    axis?: "x" | "xy" | "y";
+    boundaryRef?: React.RefObject<HTMLElement>;
+    children: React.ReactNode | ((state: {
+        dragging: boolean;
+        position: DragPosition;
+    }) => React.ReactNode);
+    disabled?: boolean;
+    initialPosition?: DragPosition;
+    restrictToBounds?: boolean;
+    targetRef?: React.RefObject<HTMLElement>;
+    onDrag?: (state: {
+        dragging: boolean;
+        position: DragPosition;
+    }) => void;
+    onDragEnd?: (position: DragPosition, overTarget: boolean) => void;
+    onDragStart?: (position: DragPosition) => void;
+    onTargetChange?: (overTarget: boolean) => void;
+}
+export declare function Draggable({ axis, boundaryRef, children, className, disabled, initialPosition, restrictToBounds, targetRef, onDrag, onDragEnd, onDragStart, onTargetChange, style, ...props }: DraggableProps): React.ReactElement;
+export interface DragDropBoardProps<T extends DropItem> extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onChange"> {
+    columns?: number;
+    items: readonly T[];
+    mode?: "insert" | "swap";
+    renderItem: (item: T, state: {
+        dragging: boolean;
+        over: boolean;
+    }) => React.ReactNode;
+    onChange?: (items: T[]) => void;
+}
+export declare function DragDropBoard<T extends DropItem>({ columns, items, mode, renderItem, className, onChange, style, ...props }: DragDropBoardProps<T>): React.ReactElement;
+export declare function FloatingBall({ adsorb, adsorbAxis, boundaryRef, children, gap, initialPosition, moveAxis, className, onPositionChange, style, ...props }: FloatingBallProps): React.ReactElement;
+export interface MultiColumnPickerProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> {
+    cascade?: boolean;
+    columns?: PickerOption[][];
+    disabled?: boolean;
+    errorClassName?: string;
+    fieldClassName?: string;
+    itemHeight?: number;
+    label?: React.ReactNode;
+    labelClassName?: string;
+    name?: FieldPath;
+    readOnly?: boolean;
+    source?: MultiColumnPickerDateSource;
+    visibleItemCount?: number;
+    values?: Array<string | number>;
+    onChange?: (values: Array<string | number>, options: PickerOption[]) => void;
+}
+export declare function MultiColumnPicker({ cascade, columns, disabled, errorClassName, fieldClassName, itemHeight, initialValue, label, labelClassName, name, readOnly, rules, source, validateOn, visibleItemCount, values, className, onChange, ...props }: MultiColumnPickerProps): React.ReactElement;
+export interface SwiperProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onChange"> {
+    autoplay?: boolean;
+    autoplayInterval?: number;
+    current?: number;
+    data: readonly T[];
+    direction?: "horizontal" | "vertical";
+    disableInitialTransition?: boolean;
+    effect?: "cinema" | "slide";
+    loop?: boolean;
+    previousIcon?: React.ReactNode;
+    nextIcon?: React.ReactNode;
+    renderItem: (item: T, index: number) => React.ReactNode;
+    showArrows?: boolean;
+    showDots?: boolean;
+    slidesPerView?: number;
+    spaceBetween?: number;
+    threshold?: number;
+    onCurrentChange?: (index: number) => void;
+}
+export declare function Swiper<T>({ autoplay, autoplayInterval, current, data, direction, disableInitialTransition, effect, loop, previousIcon, nextIcon, renderItem, showArrows, showDots, slidesPerView, spaceBetween, threshold, className, onCurrentChange, style, ...props }: SwiperProps<T>): React.ReactElement;
+export interface VirtualListProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    data: readonly T[];
+    enablePullDown?: boolean;
+    estimateSize?: number | ((index: number) => number);
+    enablePullUp?: boolean;
+    headerClassName?: string;
+    headerContent?: React.ReactNode;
+    height?: number | string;
+    itemClassName?: string;
+    itemContent: (context: {
+        data: T;
+        index: number;
+        item: VirtualItem;
+    }) => React.ReactNode;
+    listClassName?: string;
+    overscan?: number;
+    pullDownClassName?: string;
+    pullDownContent?: (context: {
+        distance: number;
+        progress: number;
+        status: "idle" | "pulling" | "ready" | "loading" | "success";
+    }) => React.ReactNode;
+    pullDownLoading?: boolean;
+    pullDownLoadingIcon?: React.ReactNode;
+    pullDownLoadingImage?: string;
+    pullDownMaxDistance?: number;
+    pullDownMinDuration?: number;
+    pullDownSuccessDuration?: number;
+    pullDownSuccessIcon?: React.ReactNode;
+    pullDownSuccessImage?: string;
+    pullDownThreshold?: number;
+    pullUpClassName?: string;
+    pullUpContent?: React.ReactNode;
+    pullUpLoading?: boolean;
+    pullUpMinDuration?: number;
+    pullUpThreshold?: number;
+    viewportClassName?: string;
+    onPullDown?: () => Promise<void> | void;
+    onPullUp?: () => Promise<void> | void;
+    onRangeChange?: (range: {
+        endIndex: number;
+        startIndex: number;
+    }) => void;
+}
+export declare function VirtualList<T>({ data, enablePullDown, estimateSize, enablePullUp, headerClassName, headerContent, height, itemClassName, itemContent, listClassName, overscan, pullDownClassName, pullDownContent, pullDownLoading, pullDownLoadingIcon, pullDownLoadingImage, pullDownMaxDistance, pullDownMinDuration, pullDownSuccessDuration, pullDownSuccessIcon, pullDownSuccessImage, pullDownThreshold, pullUpClassName, pullUpContent, pullUpLoading, pullUpMinDuration, pullUpThreshold, className, viewportClassName, onPullDown, onPullUp, onRangeChange, style, ...props }: VirtualListProps<T>): React.ReactElement;
+export interface MasonryVirtualListProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    columns?: number;
+    data: readonly T[];
+    estimateSize?: number | ((index: number, columnWidth: number) => number);
+    gap?: number;
+    headerClassName?: string;
+    headerContent?: React.ReactNode;
+    height?: number | string;
+    itemClassName?: string;
+    itemContent: (context: {
+        data: T;
+        index: number;
+        item: MasonryVirtualItem;
+    }) => React.ReactNode;
+    listClassName?: string;
+    minColumnWidth?: number;
+    overscan?: number;
+    viewportClassName?: string;
+    onRangeChange?: (range: {
+        columns: number;
+        endIndex: number;
+        startIndex: number;
+    }) => void;
+}
+export declare function MasonryVirtualList<T>({ columns, data, estimateSize, gap, headerClassName, headerContent, height, itemClassName, itemContent, listClassName, minColumnWidth, overscan, className, viewportClassName, onRangeChange, style, ...props }: MasonryVirtualListProps<T>): React.ReactElement;
+export interface ChatVirtualListProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    data: readonly T[];
+    bottomBuffer?: number;
+    bottomThreshold?: number;
+    defaultStickToBottom?: boolean;
+    enablePullUp?: boolean;
+    estimateSize?: number | ((index: number) => number);
+    getKey: (data: T, index: number) => React.Key;
+    height?: number | string;
+    itemClassName?: string;
+    itemContent: (context: {
+        data: T;
+        index: number;
+        item: VirtualItem;
+    }) => React.ReactNode;
+    listClassName?: string;
+    appendScrollBehavior?: ScrollBehavior;
+    pullUpClassName?: string;
+    pullUpContent?: React.ReactNode;
+    pullUpLoading?: boolean;
+    pullUpMinDuration?: number;
+    pullUpThreshold?: number;
+    stickToBottomOnAppend?: boolean;
+    stickToBottomOnUpdate?: boolean;
+    topLoadingClassName?: string;
+    topLoadingContent?: React.ReactNode;
+    topBuffer?: number;
+    topThreshold?: number;
+    viewportClassName?: string;
+    onPullUp?: () => Promise<void> | void;
+    onReachTop?: () => Promise<void> | void;
+    onRangeChange?: (range: {
+        endIndex: number;
+        startIndex: number;
+    }) => void;
+}
+export interface ChatVirtualListHandle {
+    scrollToBottom: (behavior?: ScrollBehavior) => boolean;
+}
+export declare const ChatVirtualList: (<T>(props: ChatVirtualListProps<T> & React.RefAttributes<ChatVirtualListHandle>) => React.ReactElement) & {
+    displayName: string;
+};
+export interface TableProps<Row extends Record<string, unknown>> extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    columns: Array<TableColumn<Row>>;
+    dataSource: Row[];
+    getRowKey?: (row: Row, index: number) => string | number;
+    emptyText?: React.ReactNode;
+    loading?: boolean;
+    loadingCoverHeader?: boolean;
+    loadingText?: React.ReactNode;
+    overscan?: number;
+    rowSelection?: boolean;
+    rowHeight?: number;
+    selectedKeys?: Array<string | number>;
+    columnSettingsSelectedIcon?: React.ReactNode;
+    settingsIcon?: React.ReactNode;
+    virtual?: boolean;
+    virtualHeight?: number;
+    onSelectionChange?: (keys: Array<string | number>) => void;
+    renderEmpty?: () => React.ReactNode;
+    renderLoading?: () => React.ReactNode;
+    renderCell?: (row: Row, column: TableColumn<Row>, rowIndex: number) => React.ReactNode;
+}
+export declare function Table<Row extends Record<string, unknown>>({ className, columns, dataSource, emptyText, getRowKey, loading, loadingCoverHeader, loadingText, overscan, rowSelection, rowHeight, selectedKeys, columnSettingsSelectedIcon, settingsIcon, style, virtual, virtualHeight, onScroll, onSelectionChange, renderEmpty, renderLoading, renderCell, ...props }: TableProps<Row>): React.ReactElement;
+export declare const VirtualTable: typeof Table;
+export declare const ConfigTable: typeof Table;
+export interface UploadProps<Values extends FormValues = FormValues> extends FieldOptions<Values>, Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    accept?: string;
+    buttonText?: React.ReactNode;
+    disabled?: boolean;
+    dragText?: React.ReactNode;
+    errorClassName?: string;
+    fieldClassName?: string;
+    initialValue?: UploadFileItem[];
+    label?: React.ReactNode;
+    labelClassName?: string;
+    maxSize?: number;
+    multiple?: boolean;
+    name?: FieldPath;
+    readOnly?: boolean;
+    removeIcon?: React.ReactNode;
+    onChange?: (files: UploadFileItem[]) => void;
+}
+export declare function Upload({ accept, buttonText, className, disabled, dragText, errorClassName, fieldClassName, initialValue, label, labelClassName, maxSize, multiple, name, readOnly, removeIcon, rules, validateOn, onChange, ...props }: UploadProps): React.ReactElement;
+export type NovelReaderAnimation = "corner" | "fade-slide" | "notebook" | "page";
+export interface NovelReaderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    animationDuration?: number;
+    animation?: NovelReaderAnimation;
+    current?: number;
+    defaultCurrent?: number;
+    loop?: boolean;
+    onPageChange?: (current: number, page: NovelReaderPage | null) => void;
+    pages: NovelReaderPage[];
+    title?: string;
+}
+export declare function NovelReader({ animation, animationDuration, className, current, defaultCurrent, loop, onPageChange, pages, style, title, ...props }: NovelReaderProps): React.ReactElement;
+export interface ComicReaderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onLoad"> {
+    current?: number;
+    defaultCurrent?: number;
+    hasMore?: boolean;
+    loading?: boolean;
+    onLoadMore?: () => void;
+    onPageChange?: (current: number, page: ComicPage | null) => void;
+    pages: ComicPage[];
+}
+export declare function ComicReader({ className, current, defaultCurrent, hasMore, loading, onLoadMore, onPageChange, pages, ...props }: ComicReaderProps): React.ReactElement;
+export interface DanmakuProps extends React.HTMLAttributes<HTMLDivElement> {
+    color?: string;
+    defaultDuration?: number;
+    enabled?: boolean;
+    items: DanmakuItem[];
+    maxTracks?: number;
+    renderItem?: (item: DanmakuItem) => React.ReactNode;
+    speed?: number;
+}
+export declare function Danmaku({ className, color, defaultDuration, enabled, items, maxTracks, renderItem, speed, style, ...props }: DanmakuProps): React.ReactElement;
+export interface LiveRoomProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSubmit"> {
+    chats?: LiveChatMessage[];
+    danmaku?: DanmakuItem[];
+    danmakuColor?: string;
+    danmakuDefaultDuration?: number;
+    danmakuEnabled?: boolean;
+    danmakuMaxTracks?: number;
+    danmakuSpeed?: number;
+    host: LiveHostInfo;
+    likeCount?: number;
+    onSendChat?: (text: string) => void;
+    sources: VideoPlayerSourceInput | VideoPlayerSourceInput[];
+}
+export declare function LiveRoom({ chats, className, danmaku, danmakuColor, danmakuDefaultDuration, danmakuEnabled, danmakuMaxTracks, danmakuSpeed, host, likeCount, onSendChat, sources, ...props }: LiveRoomProps): React.ReactElement;
+export { AffixController, BacktopController, BadgeController, BreadcrumbController, CalendarController, CanvasEditorController, CanvasImageController, ChatVirtualListController, ComicReaderController, ColorPickerController, CountdownController, DanmakuController, DatePickerController, DateRangePickerController, DesignEffectController, DragController, DropController, FilePreviewController, FloatingBallController, FormController, GestureController, GradientTextController, LazyImageController, LiveRoomController, MasonryVirtualListController, ModalController, MultiColumnPickerController, NovelReaderController, PaginationController, PasswordInputController, PopupController, ProgressController, SignatureController, SlideCaptchaController, SkeletonController, SwiperController, TableController, TabsController, TagController, TiltCardController, TimelineController, TooltipController, ToastManager, TypewriterTextController, UploadController, VerificationCodeController, VideoDetailTransitionController, VideoPlayerController, VirtualListController, VirtualSelectController, getClassComponentsLocale, };
+export { configureClassComponents, getClassComponentsConfig, resetClassComponentsConfig, } from "@class-kit/core";
+export type { PopupPlacement } from "@class-kit/core";
+export type { ToastPosition, TooltipPlacement, TooltipTrigger, } from "@class-kit/core";
+export type { TabItem, ToastItem, ToastOptions, ToastTone, } from "@class-kit/core";
+export type { VirtualItem, VirtualListOptions, VirtualListState, VirtualRange, } from "@class-kit/core";
+export type { MasonryVirtualItem, MasonryVirtualListOptions, MasonryVirtualListState, MasonryVirtualRange, } from "@class-kit/core";
+export type { ChatVirtualListOptions } from "@class-kit/core";
+export type { LazyImageOptions, LazyImageState, LazyImageStatus, } from "@class-kit/core";
+export type { ColorPickerState, DatePickerDay, DatePickerOptions, DatePickerState, DateRangePickerDay, DateRangePickerOptions, DateRangePickerState, DateRangeValue, } from "@class-kit/core";
+export type { PasswordInputOptions, PasswordInputState } from "@class-kit/core";
+export type { AffixState, BacktopState, BadgeOptions, BadgeState, BadgeTone, BreadcrumbItem, BreadcrumbState, PaginationOptions, PaginationPageItem, PaginationState, SkeletonOptions, SkeletonState, TableColumn, TableOptions, TableSelectionStatus, TableState, TagOptions, TagState, TagTone, UploadFileItem, UploadOptions, UploadState, } from "@class-kit/core";
+export type { CanvasEditorAddNodeInput, CanvasEditorLink, CanvasEditorMode, CanvasEditorNode, CanvasEditorNodeMoveInput, CanvasEditorOptions, CanvasEditorPanInput, CanvasEditorState, CanvasEditorViewport, CanvasImageImageLayer, CanvasImageLayer, CanvasImageOptions, CanvasImageRectLayer, CanvasImageState, CanvasImageTextLayer, ComicPage, ComicReaderOptions, ComicReaderState, DanmakuItem, DanmakuOptions, DanmakuState, DanmakuType, FilePreviewMode, FilePreviewOptions, FilePreviewState, FilePreviewType, LiveChatMessage, LiveHostInfo, LiveRoomOptions, LiveRoomState, NovelReaderOptions, NovelReaderPage, NovelReaderState, NovelReaderTurnDirection, NovelReaderTurnInput, NovelReaderTurnMetrics, } from "@class-kit/core";
+export type { TiltCardInput, TiltCardOptions, TiltCardState, } from "@class-kit/core";
+export type { GradientTextDirection, GradientTextOptions, GradientTextState, } from "@class-kit/core";
+export type { DesignEffectOptions, DesignEffectPreset, DesignEffectState, DesignEffectTone, } from "@class-kit/core";
+export type { TypewriterTextOptions, TypewriterTextState, } from "@class-kit/core";
+export type { FloatingBallBounds, FloatingBallEdge, FloatingBallOptions, FloatingBallPosition, FloatingBallState, DragBounds, DragControllerOptions, DragPosition, DragState, DropItem, DropState, MultiColumnPickerDateSource, MultiColumnPickerOptions, MultiColumnPickerState, PickerOption, ProgressControllerOptions, ProgressState, SignatureCanvasSize, SignatureControllerOptions, SignaturePoint, SignatureState, SignatureStroke, SlideCaptchaOptions, SlideCaptchaState, GestureDirection, GestureOptions, GesturePoint, GestureState, SwiperOptions, SwiperState, TimelineItem, TimelineOptions, TimelineState, TimelineStatus, VideoDetailItem, VideoDetailPhase, VideoDetailRect, VideoDetailTransitionOptions, VideoDetailTransitionState, VideoPlayerOptions, VideoPlayerSource, VideoPlayerSourceInput, VideoPlayerState, } from "@class-kit/core";
+export type { MarqueeDirection, MarqueeInputItem, MarqueeItem, MarqueeItemInput, MarqueeOptions, MarqueeState, MarqueeStepAnimation, MarqueeVerticalMode, } from "@class-kit/core";
+export type { ClassComponentsConfig, ClassComponentsConfigInput, ClassComponentsLocale, FieldOptions, FieldPath, FormOptions, FormState, FormValues, ValidationRule, VirtualSelectOption, VirtualSelectOptions, VirtualSelectState, VirtualSelectValue, } from "@class-kit/core";
+//# sourceMappingURL=index.d.ts.map