antd-mobile

  • Version 5.33.0
  • Published
  • 14.8 MB
  • 17 dependencies
  • MIT license

Install

npm i antd-mobile
yarn add antd-mobile
pnpm add antd-mobile

Overview

<div align="center">

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable ActionSheet

const ActionSheet: any;

    variable AutoCenter

    const AutoCenter: FC<any>;

      variable Avatar

      const Avatar: FC<any>;

        variable Badge

        const Badge: any;

          variable Button

          const Button: React.ForwardRefExoticComponent<any>;

            variable Calendar

            const Calendar: React.ForwardRefExoticComponent<any>;

              variable CalendarPicker

              const CalendarPicker: React.ForwardRefExoticComponent<any>;

                variable CalendarPickerView

                const CalendarPickerView: React.ForwardRefExoticComponent<any>;

                  variable CapsuleTabs

                  const CapsuleTabs: any;

                    variable Card

                    const Card: FC<any>;

                      variable CascadePicker

                      const CascadePicker: any;

                        variable CascadePickerView

                        const CascadePickerView: FC<CascadePickerViewProps>;

                          variable Cascader

                          const Cascader: any;

                            variable CascaderView

                            const CascaderView: any;

                              variable CenterPopup

                              const CenterPopup: FC<any>;

                                variable Checkbox

                                const Checkbox: any;

                                  variable CheckList

                                  const CheckList: any;

                                    variable Collapse

                                    const Collapse: any;

                                      variable ConfigProvider

                                      const ConfigProvider: FC<Config>;

                                        variable DatePicker

                                        const DatePicker: any;

                                          variable DatePickerView

                                          const DatePickerView: FC<any>;

                                            variable Dialog

                                            const Dialog: any;

                                              variable Divider

                                              const Divider: FC<any>;

                                                variable DotLoading

                                                const DotLoading: React.NamedExoticComponent<any>;
                                                  const Dropdown: any;

                                                    variable Ellipsis

                                                    const Ellipsis: FC<any>;

                                                      variable Empty

                                                      const Empty: FC<any>;
                                                      • Deprecated

                                                        Empty has been deprecated and will be removed in the next major version.

                                                      variable ErrorBlock

                                                      const ErrorBlock: any;

                                                        variable FloatingBubble

                                                        const FloatingBubble: FC<any>;

                                                          variable FloatingPanel

                                                          const FloatingPanel: React.ForwardRefExoticComponent<any>;
                                                            const Footer: FC<any>;

                                                              variable Form

                                                              const Form: any;

                                                                variable Grid

                                                                const Grid: any;

                                                                  variable Image

                                                                  const Image: React.FC<any>;

                                                                    variable ImageUploader

                                                                    const ImageUploader: React.ForwardRefExoticComponent<any>;

                                                                      variable ImageViewer

                                                                      const ImageViewer: any;

                                                                        variable IndexBar

                                                                        const IndexBar: any;

                                                                          variable InfiniteScroll

                                                                          const InfiniteScroll: FC<any>;

                                                                            variable Input

                                                                            const Input: React.ForwardRefExoticComponent<any>;

                                                                              variable JumboTabs

                                                                              const JumboTabs: any;

                                                                                variable List

                                                                                const List: any;

                                                                                  variable Loading

                                                                                  const Loading: React.NamedExoticComponent<any>;

                                                                                    variable Mask

                                                                                    const Mask: FC<any>;
                                                                                      const Modal: any;
                                                                                        const NavBar: FC<any>;

                                                                                          variable NoticeBar

                                                                                          const NoticeBar: React.NamedExoticComponent<any>;

                                                                                            variable NumberKeyboard

                                                                                            const NumberKeyboard: FC<any>;

                                                                                              variable PageIndicator

                                                                                              const PageIndicator: React.NamedExoticComponent<any>;

                                                                                                variable PasscodeInput

                                                                                                const PasscodeInput: React.ForwardRefExoticComponent<any>;

                                                                                                  variable Picker

                                                                                                  const Picker: any;

                                                                                                    variable PickerView

                                                                                                    const PickerView: React.NamedExoticComponent<any>;

                                                                                                      variable Popover

                                                                                                      const Popover: any;
                                                                                                        const Popup: FC<any>;

                                                                                                          variable ProgressBar

                                                                                                          const ProgressBar: FC<any>;

                                                                                                            variable ProgressCircle

                                                                                                            const ProgressCircle: FC<any>;

                                                                                                              variable PullToRefresh

                                                                                                              const PullToRefresh: FC<PullToRefreshProps>;

                                                                                                                variable Radio

                                                                                                                const Radio: any;

                                                                                                                  variable Rate

                                                                                                                  const Rate: FC<any>;

                                                                                                                    variable Result

                                                                                                                    const Result: FC<any>;

                                                                                                                      variable ResultPage

                                                                                                                      const ResultPage: any;

                                                                                                                        variable SafeArea

                                                                                                                        const SafeArea: FC<any>;

                                                                                                                          variable ScrollMask

                                                                                                                          const ScrollMask: FC<ScrollMaskProps>;
                                                                                                                            const SearchBar: React.ForwardRefExoticComponent<any>;
                                                                                                                              const SideBar: any;

                                                                                                                                variable Skeleton

                                                                                                                                const Skeleton: any;

                                                                                                                                  variable Slider

                                                                                                                                  const Slider: FC<any>;

                                                                                                                                    variable Space

                                                                                                                                    const Space: FC<any>;

                                                                                                                                      variable SpinLoading

                                                                                                                                      const SpinLoading: React.NamedExoticComponent<any>;

                                                                                                                                        variable Stepper

                                                                                                                                        const Stepper: React.ForwardRefExoticComponent<any>;

                                                                                                                                          variable Steps

                                                                                                                                          const Steps: any;

                                                                                                                                            variable SwipeAction

                                                                                                                                            const SwipeAction: React.ForwardRefExoticComponent<any>;

                                                                                                                                              variable Swiper

                                                                                                                                              const Swiper: any;

                                                                                                                                                variable Switch

                                                                                                                                                const Switch: FC<any>;

                                                                                                                                                  variable TabBar

                                                                                                                                                  const TabBar: any;

                                                                                                                                                    variable Tabs

                                                                                                                                                    const Tabs: any;

                                                                                                                                                      variable Tag

                                                                                                                                                      const Tag: FC<any>;

                                                                                                                                                        variable TextArea

                                                                                                                                                        const TextArea: React.ForwardRefExoticComponent<any>;

                                                                                                                                                          variable Toast

                                                                                                                                                          const Toast: { show: typeof show; clear: typeof clear; config: typeof config };

                                                                                                                                                            variable TreeSelect

                                                                                                                                                            const TreeSelect: any;

                                                                                                                                                              variable VirtualInput

                                                                                                                                                              const VirtualInput: React.ForwardRefExoticComponent<any>;

                                                                                                                                                                variable WaterMark

                                                                                                                                                                const WaterMark: FC<any>;

                                                                                                                                                                  Functions

                                                                                                                                                                  function createErrorBlock

                                                                                                                                                                  createErrorBlock: (imageRecord: ImageRecord) => React.FC<any>;

                                                                                                                                                                    function reduceMotion

                                                                                                                                                                    reduceMotion: () => void;

                                                                                                                                                                      function restoreMotion

                                                                                                                                                                      restoreMotion: () => void;

                                                                                                                                                                        function Selector

                                                                                                                                                                        Selector: <V extends SelectorValue>(p: any) => React.ReactElement<any, any>;

                                                                                                                                                                          function setDefaultConfig

                                                                                                                                                                          setDefaultConfig: (config: Config) => void;

                                                                                                                                                                            Interfaces

                                                                                                                                                                            interface CheckboxGroupProps

                                                                                                                                                                            interface CheckboxGroupProps {}

                                                                                                                                                                              property children

                                                                                                                                                                              children?: ReactNode;

                                                                                                                                                                                property defaultValue

                                                                                                                                                                                defaultValue?: CheckboxValue[];

                                                                                                                                                                                  property disabled

                                                                                                                                                                                  disabled?: boolean;

                                                                                                                                                                                    property onChange

                                                                                                                                                                                    onChange?: (val: CheckboxValue[]) => void;

                                                                                                                                                                                      property value

                                                                                                                                                                                      value?: CheckboxValue[];

                                                                                                                                                                                        interface ImageUploaderRef

                                                                                                                                                                                        interface ImageUploaderRef {}

                                                                                                                                                                                          property nativeElement

                                                                                                                                                                                          nativeElement: HTMLInputElement | null;

                                                                                                                                                                                            interface ImageUploadItem

                                                                                                                                                                                            interface ImageUploadItem {}

                                                                                                                                                                                              property extra

                                                                                                                                                                                              extra?: any;

                                                                                                                                                                                                property key

                                                                                                                                                                                                key?: string | number;

                                                                                                                                                                                                  property thumbnailUrl

                                                                                                                                                                                                  thumbnailUrl?: string;

                                                                                                                                                                                                    property url

                                                                                                                                                                                                    url: string;

                                                                                                                                                                                                      interface RadioGroupProps

                                                                                                                                                                                                      interface RadioGroupProps {}

                                                                                                                                                                                                        property children

                                                                                                                                                                                                        children?: ReactNode;

                                                                                                                                                                                                          property defaultValue

                                                                                                                                                                                                          defaultValue?: RadioValue | null;

                                                                                                                                                                                                            property disabled

                                                                                                                                                                                                            disabled?: boolean;

                                                                                                                                                                                                              property onChange

                                                                                                                                                                                                              onChange?: (val: RadioValue) => void;

                                                                                                                                                                                                                property value

                                                                                                                                                                                                                value?: RadioValue | null;

                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                  type ActionSheetProps

                                                                                                                                                                                                                  type ActionSheetProps = {
                                                                                                                                                                                                                  visible?: boolean;
                                                                                                                                                                                                                  actions: Action[];
                                                                                                                                                                                                                  extra?: ReactNode;
                                                                                                                                                                                                                  cancelText?: ReactNode;
                                                                                                                                                                                                                  onAction?: (action: Action, index: number) => void;
                                                                                                                                                                                                                  onClose?: () => void;
                                                                                                                                                                                                                  onMaskClick?: () => void;
                                                                                                                                                                                                                  closeOnAction?: boolean;
                                                                                                                                                                                                                  closeOnMaskClick?: boolean;
                                                                                                                                                                                                                  safeArea?: boolean;
                                                                                                                                                                                                                  popupClassName?: string;
                                                                                                                                                                                                                  /** @deprecated use `styles` instead */
                                                                                                                                                                                                                  popupStyle?: CSSProperties;
                                                                                                                                                                                                                  styles?: Partial<Record<'body' | 'mask', CSSProperties>>;
                                                                                                                                                                                                                  } & Pick<
                                                                                                                                                                                                                  PopupProps,
                                                                                                                                                                                                                  'afterClose' | 'getContainer' | 'destroyOnClose' | 'forceRender'
                                                                                                                                                                                                                  > &
                                                                                                                                                                                                                  NativeProps;

                                                                                                                                                                                                                    type AutoCenterProps

                                                                                                                                                                                                                    type AutoCenterProps = {
                                                                                                                                                                                                                    children?: ReactNode;
                                                                                                                                                                                                                    } & NativeProps;

                                                                                                                                                                                                                      type AvatarProps

                                                                                                                                                                                                                      type AvatarProps = {
                                                                                                                                                                                                                      src: string;
                                                                                                                                                                                                                      fallback?: ReactNode;
                                                                                                                                                                                                                      fit?: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
                                                                                                                                                                                                                      } & Pick<ImageProps, 'alt' | 'lazy' | 'onClick' | 'onError' | 'onLoad'> &
                                                                                                                                                                                                                      NativeProps<'--size' | '--border-radius'>;

                                                                                                                                                                                                                        type BadgeProps

                                                                                                                                                                                                                        type BadgeProps = {
                                                                                                                                                                                                                        content?: ReactNode | typeof dot;
                                                                                                                                                                                                                        color?: string;
                                                                                                                                                                                                                        bordered?: boolean;
                                                                                                                                                                                                                        children?: ReactNode;
                                                                                                                                                                                                                        wrapperClassName?: string;
                                                                                                                                                                                                                        wrapperStyle?: CSSProperties;
                                                                                                                                                                                                                        } & NativeProps<'--right' | '--top' | '--color'>;

                                                                                                                                                                                                                          type ButtonProps

                                                                                                                                                                                                                          type ButtonProps = {
                                                                                                                                                                                                                          color?: 'default' | 'primary' | 'success' | 'warning' | 'danger';
                                                                                                                                                                                                                          fill?: 'solid' | 'outline' | 'none';
                                                                                                                                                                                                                          size?: 'mini' | 'small' | 'middle' | 'large';
                                                                                                                                                                                                                          block?: boolean;
                                                                                                                                                                                                                          loading?: boolean | 'auto';
                                                                                                                                                                                                                          loadingText?: string;
                                                                                                                                                                                                                          loadingIcon?: ReactNode;
                                                                                                                                                                                                                          disabled?: boolean;
                                                                                                                                                                                                                          onClick?: (
                                                                                                                                                                                                                          event: React.MouseEvent<HTMLButtonElement, MouseEvent>
                                                                                                                                                                                                                          ) => void | Promise<void> | unknown;
                                                                                                                                                                                                                          type?: 'submit' | 'reset' | 'button';
                                                                                                                                                                                                                          shape?: 'default' | 'rounded' | 'rectangular';
                                                                                                                                                                                                                          children?: ReactNode;
                                                                                                                                                                                                                          } & Pick<
                                                                                                                                                                                                                          NativeButtonProps,
                                                                                                                                                                                                                          'onMouseDown' | 'onMouseUp' | 'onTouchStart' | 'onTouchEnd' | 'id'
                                                                                                                                                                                                                          > &
                                                                                                                                                                                                                          NativeProps<
                                                                                                                                                                                                                          | '--text-color'
                                                                                                                                                                                                                          | '--background-color'
                                                                                                                                                                                                                          | '--border-radius'
                                                                                                                                                                                                                          | '--border-width'
                                                                                                                                                                                                                          | '--border-style'
                                                                                                                                                                                                                          | '--border-color'
                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                            type ButtonRef

                                                                                                                                                                                                                            type ButtonRef = {
                                                                                                                                                                                                                            nativeElement: HTMLButtonElement | null;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              type CalendarPickerProps

                                                                                                                                                                                                                              type CalendarPickerProps = CalendarPickerViewProps & {
                                                                                                                                                                                                                              visible?: boolean;
                                                                                                                                                                                                                              confirmText?: string;
                                                                                                                                                                                                                              popupClassName?: string;
                                                                                                                                                                                                                              popupStyle?: React.CSSProperties;
                                                                                                                                                                                                                              popupBodyStyle?: React.CSSProperties;
                                                                                                                                                                                                                              forceRender?: true;
                                                                                                                                                                                                                              closeOnMaskClick?: boolean;
                                                                                                                                                                                                                              onClose?: () => void;
                                                                                                                                                                                                                              onMaskClick?: () => void;
                                                                                                                                                                                                                              } & (
                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                              selectionMode?: undefined;
                                                                                                                                                                                                                              onConfirm?: undefined;
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                              selectionMode: 'single';
                                                                                                                                                                                                                              onConfirm?: (val: Date | null) => void;
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                              selectionMode: 'range';
                                                                                                                                                                                                                              onConfirm?: (val: [Date, Date] | null) => void;
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                type CalendarPickerRef

                                                                                                                                                                                                                                type CalendarPickerRef = CalendarPickerViewRef;

                                                                                                                                                                                                                                  type CalendarPickerViewProps

                                                                                                                                                                                                                                  type CalendarPickerViewProps = {
                                                                                                                                                                                                                                  title?: React.ReactNode;
                                                                                                                                                                                                                                  confirmText?: string;
                                                                                                                                                                                                                                  weekStartsOn?: 'Monday' | 'Sunday';
                                                                                                                                                                                                                                  renderTop?: (date: Date) => React.ReactNode;
                                                                                                                                                                                                                                  renderDate?: (date: Date) => React.ReactNode;
                                                                                                                                                                                                                                  renderBottom?: (date: Date) => React.ReactNode;
                                                                                                                                                                                                                                  allowClear?: boolean;
                                                                                                                                                                                                                                  max?: Date;
                                                                                                                                                                                                                                  min?: Date;
                                                                                                                                                                                                                                  shouldDisableDate?: (date: Date) => boolean;
                                                                                                                                                                                                                                  } & (
                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                  selectionMode?: undefined;
                                                                                                                                                                                                                                  value?: undefined;
                                                                                                                                                                                                                                  defaultValue?: undefined;
                                                                                                                                                                                                                                  onChange?: undefined;
                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                  selectionMode: 'single';
                                                                                                                                                                                                                                  value?: Date | null;
                                                                                                                                                                                                                                  defaultValue?: Date | null;
                                                                                                                                                                                                                                  onChange?: (val: Date | null) => void;
                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                  selectionMode: 'range';
                                                                                                                                                                                                                                  value?: [Date, Date] | null;
                                                                                                                                                                                                                                  defaultValue?: [Date, Date] | null;
                                                                                                                                                                                                                                  onChange?: (val: [Date, Date] | null) => void;
                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                  ) &
                                                                                                                                                                                                                                  NativeProps;

                                                                                                                                                                                                                                    type CalendarPickerViewRef

                                                                                                                                                                                                                                    type CalendarPickerViewRef = {
                                                                                                                                                                                                                                    jumpTo: (page: Page | ((page: Page) => Page)) => void;
                                                                                                                                                                                                                                    jumpToToday: () => void;
                                                                                                                                                                                                                                    getDateRange: () => DateRange;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      type CalendarProps

                                                                                                                                                                                                                                      type CalendarProps = {
                                                                                                                                                                                                                                      prevMonthButton?: React.ReactNode;
                                                                                                                                                                                                                                      prevYearButton?: React.ReactNode;
                                                                                                                                                                                                                                      nextMonthButton?: React.ReactNode;
                                                                                                                                                                                                                                      nextYearButton?: React.ReactNode;
                                                                                                                                                                                                                                      onPageChange?: (year: number, month: number) => void;
                                                                                                                                                                                                                                      weekStartsOn?: 'Monday' | 'Sunday';
                                                                                                                                                                                                                                      renderLabel?: (date: Date) => React.ReactNode;
                                                                                                                                                                                                                                      renderDate?: (date: Date) => React.ReactNode;
                                                                                                                                                                                                                                      allowClear?: boolean;
                                                                                                                                                                                                                                      max?: Date;
                                                                                                                                                                                                                                      min?: Date;
                                                                                                                                                                                                                                      shouldDisableDate?: (date: Date) => boolean;
                                                                                                                                                                                                                                      minPage?: Page;
                                                                                                                                                                                                                                      maxPage?: Page;
                                                                                                                                                                                                                                      } & (
                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                      selectionMode?: undefined;
                                                                                                                                                                                                                                      value?: undefined;
                                                                                                                                                                                                                                      defaultValue?: undefined;
                                                                                                                                                                                                                                      onChange?: undefined;
                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                      selectionMode: 'single';
                                                                                                                                                                                                                                      value?: Date | null;
                                                                                                                                                                                                                                      defaultValue?: Date | null;
                                                                                                                                                                                                                                      onChange?: (val: Date | null) => void;
                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                      selectionMode: 'range';
                                                                                                                                                                                                                                      value?: [Date, Date] | null;
                                                                                                                                                                                                                                      defaultValue?: [Date, Date] | null;
                                                                                                                                                                                                                                      onChange?: (val: [Date, Date] | null) => void;
                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                      ) &
                                                                                                                                                                                                                                      NativeProps;

                                                                                                                                                                                                                                        type CalendarRef

                                                                                                                                                                                                                                        type CalendarRef = {
                                                                                                                                                                                                                                        jumpTo: (page: Page | ((page: Page) => Page)) => void;
                                                                                                                                                                                                                                        jumpToToday: () => void;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          type CapsuleTabProps

                                                                                                                                                                                                                                          type CapsuleTabProps = {
                                                                                                                                                                                                                                          title: ReactNode;
                                                                                                                                                                                                                                          disabled?: boolean;
                                                                                                                                                                                                                                          forceRender?: boolean;
                                                                                                                                                                                                                                          destroyOnClose?: boolean;
                                                                                                                                                                                                                                          children?: ReactNode;
                                                                                                                                                                                                                                          } & NativeProps;

                                                                                                                                                                                                                                            type CapsuleTabsProps

                                                                                                                                                                                                                                            type CapsuleTabsProps = {
                                                                                                                                                                                                                                            activeKey?: string | null;
                                                                                                                                                                                                                                            defaultActiveKey?: string | null;
                                                                                                                                                                                                                                            onChange?: (key: string) => void;
                                                                                                                                                                                                                                            children?: ReactNode;
                                                                                                                                                                                                                                            } & NativeProps;

                                                                                                                                                                                                                                              type CardProps

                                                                                                                                                                                                                                              type CardProps = {
                                                                                                                                                                                                                                              title?: ReactNode;
                                                                                                                                                                                                                                              extra?: ReactNode;
                                                                                                                                                                                                                                              headerStyle?: CSSProperties;
                                                                                                                                                                                                                                              headerClassName?: string;
                                                                                                                                                                                                                                              bodyStyle?: CSSProperties;
                                                                                                                                                                                                                                              bodyClassName?: string;
                                                                                                                                                                                                                                              onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                              onBodyClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                              onHeaderClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                              children?: ReactNode;
                                                                                                                                                                                                                                              } & NativeProps;

                                                                                                                                                                                                                                                type CascadePickerOption

                                                                                                                                                                                                                                                type CascadePickerOption = {
                                                                                                                                                                                                                                                label: string;
                                                                                                                                                                                                                                                value: string;
                                                                                                                                                                                                                                                children?: CascadePickerOption[];
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  type CascadePickerProps

                                                                                                                                                                                                                                                  type CascadePickerProps = Omit<PickerProps, 'columns'> & {
                                                                                                                                                                                                                                                  options: CascadePickerOption[];
                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                    type CascadePickerRef

                                                                                                                                                                                                                                                    type CascadePickerRef = PickerRef;

                                                                                                                                                                                                                                                      type CascadePickerViewProps

                                                                                                                                                                                                                                                      type CascadePickerViewProps = Omit<PickerViewProps, 'columns'> & {
                                                                                                                                                                                                                                                      options: CascadePickerOption[];
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        type CascaderOption

                                                                                                                                                                                                                                                        type CascaderOption = {
                                                                                                                                                                                                                                                        label?: string;
                                                                                                                                                                                                                                                        value?: string;
                                                                                                                                                                                                                                                        disabled?: boolean;
                                                                                                                                                                                                                                                        children?: CascaderOption[];
                                                                                                                                                                                                                                                        } & BaseOptionType;

                                                                                                                                                                                                                                                          type CascaderProps

                                                                                                                                                                                                                                                          type CascaderProps = {
                                                                                                                                                                                                                                                          options: CascaderOption[];
                                                                                                                                                                                                                                                          value?: CascaderValue[];
                                                                                                                                                                                                                                                          defaultValue?: CascaderValue[];
                                                                                                                                                                                                                                                          placeholder?: string;
                                                                                                                                                                                                                                                          onSelect?: (value: CascaderValue[], extend: CascaderValueExtend) => void;
                                                                                                                                                                                                                                                          onConfirm?: (value: CascaderValue[], extend: CascaderValueExtend) => void;
                                                                                                                                                                                                                                                          onCancel?: () => void;
                                                                                                                                                                                                                                                          onClose?: () => void;
                                                                                                                                                                                                                                                          visible?: boolean;
                                                                                                                                                                                                                                                          title?: ReactNode;
                                                                                                                                                                                                                                                          confirmText?: ReactNode;
                                                                                                                                                                                                                                                          cancelText?: ReactNode;
                                                                                                                                                                                                                                                          loading?: boolean;
                                                                                                                                                                                                                                                          children?: (
                                                                                                                                                                                                                                                          items: (CascaderOption | null)[],
                                                                                                                                                                                                                                                          actions: CascaderActions
                                                                                                                                                                                                                                                          ) => ReactNode;
                                                                                                                                                                                                                                                          onTabsChange?: (index: number) => void;
                                                                                                                                                                                                                                                          activeIcon?: ReactNode;
                                                                                                                                                                                                                                                          fieldNames?: FieldNamesType;
                                                                                                                                                                                                                                                          } & Pick<
                                                                                                                                                                                                                                                          PopupProps,
                                                                                                                                                                                                                                                          | 'getContainer'
                                                                                                                                                                                                                                                          | 'afterShow'
                                                                                                                                                                                                                                                          | 'afterClose'
                                                                                                                                                                                                                                                          | 'onClick'
                                                                                                                                                                                                                                                          | 'stopPropagation'
                                                                                                                                                                                                                                                          | 'destroyOnClose'
                                                                                                                                                                                                                                                          | 'forceRender'
                                                                                                                                                                                                                                                          > &
                                                                                                                                                                                                                                                          NativeProps;

                                                                                                                                                                                                                                                            type CascaderRef

                                                                                                                                                                                                                                                            type CascaderRef = CascaderActions;

                                                                                                                                                                                                                                                              type CascaderViewProps

                                                                                                                                                                                                                                                              type CascaderViewProps = {
                                                                                                                                                                                                                                                              options: CascaderOption[];
                                                                                                                                                                                                                                                              value?: CascaderValue[];
                                                                                                                                                                                                                                                              defaultValue?: CascaderValue[];
                                                                                                                                                                                                                                                              onChange?: (value: CascaderValue[], extend: CascaderValueExtend) => void;
                                                                                                                                                                                                                                                              placeholder?: string | ((index: number) => string);
                                                                                                                                                                                                                                                              onTabsChange?: (index: number) => void;
                                                                                                                                                                                                                                                              activeIcon?: ReactNode;
                                                                                                                                                                                                                                                              loading?: boolean;
                                                                                                                                                                                                                                                              fieldNames?: FieldNamesType;
                                                                                                                                                                                                                                                              } & NativeProps<'--height'>;

                                                                                                                                                                                                                                                                type CenterPopupProps

                                                                                                                                                                                                                                                                type CenterPopupProps = PopupBaseProps &
                                                                                                                                                                                                                                                                PropsWithChildren<{
                                                                                                                                                                                                                                                                role?: string;
                                                                                                                                                                                                                                                                }> &
                                                                                                                                                                                                                                                                NativeProps<
                                                                                                                                                                                                                                                                | '--background-color'
                                                                                                                                                                                                                                                                | '--border-radius'
                                                                                                                                                                                                                                                                | '--max-width'
                                                                                                                                                                                                                                                                | '--min-width'
                                                                                                                                                                                                                                                                | '--z-index'
                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                  type CheckboxProps

                                                                                                                                                                                                                                                                  type CheckboxProps = {
                                                                                                                                                                                                                                                                  checked?: boolean;
                                                                                                                                                                                                                                                                  defaultChecked?: boolean;
                                                                                                                                                                                                                                                                  disabled?: boolean;
                                                                                                                                                                                                                                                                  onChange?: (checked: boolean) => void;
                                                                                                                                                                                                                                                                  value?: CheckboxValue;
                                                                                                                                                                                                                                                                  indeterminate?: boolean;
                                                                                                                                                                                                                                                                  block?: boolean;
                                                                                                                                                                                                                                                                  id?: string;
                                                                                                                                                                                                                                                                  icon?: (checked: boolean, indeterminate: boolean) => ReactNode;
                                                                                                                                                                                                                                                                  children?: ReactNode;
                                                                                                                                                                                                                                                                  onClick?: (event: React.MouseEvent<HTMLLabelElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                  } & NativeProps<'--icon-size' | '--font-size' | '--gap'>;

                                                                                                                                                                                                                                                                    type CheckboxRef

                                                                                                                                                                                                                                                                    type CheckboxRef = {
                                                                                                                                                                                                                                                                    check: () => void;
                                                                                                                                                                                                                                                                    uncheck: () => void;
                                                                                                                                                                                                                                                                    toggle: () => void;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      type CheckListItemProps

                                                                                                                                                                                                                                                                      type CheckListItemProps = Pick<
                                                                                                                                                                                                                                                                      ListItemProps,
                                                                                                                                                                                                                                                                      | 'title'
                                                                                                                                                                                                                                                                      | 'children'
                                                                                                                                                                                                                                                                      | 'description'
                                                                                                                                                                                                                                                                      | 'prefix'
                                                                                                                                                                                                                                                                      | 'disabled'
                                                                                                                                                                                                                                                                      | 'onClick'
                                                                                                                                                                                                                                                                      | 'style'
                                                                                                                                                                                                                                                                      > & {
                                                                                                                                                                                                                                                                      value: CheckListValue;
                                                                                                                                                                                                                                                                      readOnly?: boolean;
                                                                                                                                                                                                                                                                      } & NativeProps;

                                                                                                                                                                                                                                                                        type CheckListProps

                                                                                                                                                                                                                                                                        type CheckListProps = Pick<ListProps, 'mode' | 'style'> & {
                                                                                                                                                                                                                                                                        defaultValue?: CheckListValue[];
                                                                                                                                                                                                                                                                        value?: CheckListValue[];
                                                                                                                                                                                                                                                                        onChange?: (val: CheckListValue[]) => void;
                                                                                                                                                                                                                                                                        multiple?: boolean;
                                                                                                                                                                                                                                                                        activeIcon?: ReactNode;
                                                                                                                                                                                                                                                                        extra?: (active: boolean) => ReactNode;
                                                                                                                                                                                                                                                                        disabled?: boolean;
                                                                                                                                                                                                                                                                        readOnly?: boolean;
                                                                                                                                                                                                                                                                        children?: ReactNode;
                                                                                                                                                                                                                                                                        } & NativeProps;

                                                                                                                                                                                                                                                                          type CollapsePanelProps

                                                                                                                                                                                                                                                                          type CollapsePanelProps = {
                                                                                                                                                                                                                                                                          key: string;
                                                                                                                                                                                                                                                                          title: ReactNode;
                                                                                                                                                                                                                                                                          disabled?: boolean;
                                                                                                                                                                                                                                                                          forceRender?: boolean;
                                                                                                                                                                                                                                                                          destroyOnClose?: boolean;
                                                                                                                                                                                                                                                                          onClick?: (event: React.MouseEvent<Element, MouseEvent>) => void;
                                                                                                                                                                                                                                                                          arrow?: ReactNode | ((active: boolean) => ReactNode);
                                                                                                                                                                                                                                                                          children?: ReactNode;
                                                                                                                                                                                                                                                                          } & NativeProps;

                                                                                                                                                                                                                                                                            type CollapseProps

                                                                                                                                                                                                                                                                            type CollapseProps = (
                                                                                                                                                                                                                                                                            | ({
                                                                                                                                                                                                                                                                            accordion?: false;
                                                                                                                                                                                                                                                                            } & ValueProps<string[]>)
                                                                                                                                                                                                                                                                            | ({
                                                                                                                                                                                                                                                                            accordion: true;
                                                                                                                                                                                                                                                                            } & ValueProps<string | null>)
                                                                                                                                                                                                                                                                            ) & {
                                                                                                                                                                                                                                                                            children?: ReactNode;
                                                                                                                                                                                                                                                                            } & NativeProps;

                                                                                                                                                                                                                                                                              type ConfigProviderProps

                                                                                                                                                                                                                                                                              type ConfigProviderProps = Config;

                                                                                                                                                                                                                                                                                type DatePickerProps

                                                                                                                                                                                                                                                                                type DatePickerProps = Pick<
                                                                                                                                                                                                                                                                                PickerProps,
                                                                                                                                                                                                                                                                                | 'onCancel'
                                                                                                                                                                                                                                                                                | 'onClose'
                                                                                                                                                                                                                                                                                | 'closeOnMaskClick'
                                                                                                                                                                                                                                                                                | 'visible'
                                                                                                                                                                                                                                                                                | 'confirmText'
                                                                                                                                                                                                                                                                                | 'cancelText'
                                                                                                                                                                                                                                                                                | 'getContainer'
                                                                                                                                                                                                                                                                                | 'loading'
                                                                                                                                                                                                                                                                                | 'loadingContent'
                                                                                                                                                                                                                                                                                | 'afterShow'
                                                                                                                                                                                                                                                                                | 'afterClose'
                                                                                                                                                                                                                                                                                | 'onClick'
                                                                                                                                                                                                                                                                                | 'title'
                                                                                                                                                                                                                                                                                | 'stopPropagation'
                                                                                                                                                                                                                                                                                | 'style'
                                                                                                                                                                                                                                                                                | 'mouseWheel'
                                                                                                                                                                                                                                                                                | 'forceRender'
                                                                                                                                                                                                                                                                                | 'destroyOnClose'
                                                                                                                                                                                                                                                                                > & {
                                                                                                                                                                                                                                                                                value?: PickerDate | null;
                                                                                                                                                                                                                                                                                defaultValue?: PickerDate | null;
                                                                                                                                                                                                                                                                                onSelect?: (value: PickerDate) => void;
                                                                                                                                                                                                                                                                                onConfirm?: (value: PickerDate) => void;
                                                                                                                                                                                                                                                                                min?: PickerDate;
                                                                                                                                                                                                                                                                                max?: PickerDate;
                                                                                                                                                                                                                                                                                precision?: Precision;
                                                                                                                                                                                                                                                                                children?: (value: PickerDate | null, actions: PickerActions) => ReactNode;
                                                                                                                                                                                                                                                                                renderLabel?: RenderLabel;
                                                                                                                                                                                                                                                                                filter?: DatePickerFilter;
                                                                                                                                                                                                                                                                                tillNow?: boolean;
                                                                                                                                                                                                                                                                                } & NativeProps;

                                                                                                                                                                                                                                                                                  type DatePickerRef

                                                                                                                                                                                                                                                                                  type DatePickerRef = PickerRef;

                                                                                                                                                                                                                                                                                    type DatePickerViewProps

                                                                                                                                                                                                                                                                                    type DatePickerViewProps = Pick<
                                                                                                                                                                                                                                                                                    PickerViewProps,
                                                                                                                                                                                                                                                                                    'style' | 'mouseWheel' | 'loading' | 'loadingContent'
                                                                                                                                                                                                                                                                                    > & {
                                                                                                                                                                                                                                                                                    value?: PickerDate;
                                                                                                                                                                                                                                                                                    defaultValue?: PickerDate;
                                                                                                                                                                                                                                                                                    onChange?: (value: PickerDate) => void;
                                                                                                                                                                                                                                                                                    min?: PickerDate;
                                                                                                                                                                                                                                                                                    max?: PickerDate;
                                                                                                                                                                                                                                                                                    precision?: Precision;
                                                                                                                                                                                                                                                                                    renderLabel?: RenderLabel;
                                                                                                                                                                                                                                                                                    filter?: DatePickerFilter;
                                                                                                                                                                                                                                                                                    tillNow?: boolean;
                                                                                                                                                                                                                                                                                    } & NativeProps;

                                                                                                                                                                                                                                                                                      type DialogAlertProps

                                                                                                                                                                                                                                                                                      type DialogAlertProps = Omit<
                                                                                                                                                                                                                                                                                      DialogProps,
                                                                                                                                                                                                                                                                                      'visible' | 'closeOnAction' | 'actions'
                                                                                                                                                                                                                                                                                      > & {
                                                                                                                                                                                                                                                                                      confirmText?: ReactNode;
                                                                                                                                                                                                                                                                                      onConfirm?: () => void | Promise<void>;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        type DialogConfirmProps

                                                                                                                                                                                                                                                                                        type DialogConfirmProps = Omit<
                                                                                                                                                                                                                                                                                        DialogProps,
                                                                                                                                                                                                                                                                                        'visible' | 'closeOnAction' | 'actions'
                                                                                                                                                                                                                                                                                        > & {
                                                                                                                                                                                                                                                                                        confirmText?: ReactNode;
                                                                                                                                                                                                                                                                                        cancelText?: ReactNode;
                                                                                                                                                                                                                                                                                        onConfirm?: () => void | Promise<void>;
                                                                                                                                                                                                                                                                                        onCancel?: () => void | Promise<void>;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          type DialogProps

                                                                                                                                                                                                                                                                                          type DialogProps = Pick<
                                                                                                                                                                                                                                                                                          CenterPopupProps,
                                                                                                                                                                                                                                                                                          | 'afterClose'
                                                                                                                                                                                                                                                                                          | 'afterShow'
                                                                                                                                                                                                                                                                                          | 'bodyClassName'
                                                                                                                                                                                                                                                                                          | 'bodyStyle'
                                                                                                                                                                                                                                                                                          | 'destroyOnClose'
                                                                                                                                                                                                                                                                                          | 'disableBodyScroll'
                                                                                                                                                                                                                                                                                          | 'forceRender'
                                                                                                                                                                                                                                                                                          | 'getContainer'
                                                                                                                                                                                                                                                                                          | 'maskClassName'
                                                                                                                                                                                                                                                                                          | 'maskStyle'
                                                                                                                                                                                                                                                                                          | 'stopPropagation'
                                                                                                                                                                                                                                                                                          | 'visible'
                                                                                                                                                                                                                                                                                          > & {
                                                                                                                                                                                                                                                                                          image?: string;
                                                                                                                                                                                                                                                                                          header?: ReactNode;
                                                                                                                                                                                                                                                                                          title?: ReactNode;
                                                                                                                                                                                                                                                                                          content?: ReactNode;
                                                                                                                                                                                                                                                                                          actions?: (Action | Action[])[];
                                                                                                                                                                                                                                                                                          onAction?: (action: Action, index: number) => void | Promise<void>;
                                                                                                                                                                                                                                                                                          onClose?: () => void;
                                                                                                                                                                                                                                                                                          closeOnAction?: boolean;
                                                                                                                                                                                                                                                                                          closeOnMaskClick?: boolean;
                                                                                                                                                                                                                                                                                          } & NativeProps;

                                                                                                                                                                                                                                                                                            type DialogShowProps

                                                                                                                                                                                                                                                                                            type DialogShowProps = Omit<
                                                                                                                                                                                                                                                                                            DialogProps,
                                                                                                                                                                                                                                                                                            'visible' | 'destroyOnClose' | 'forceRender'
                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                              type DividerProps

                                                                                                                                                                                                                                                                                              type DividerProps = {
                                                                                                                                                                                                                                                                                              contentPosition?: 'left' | 'right' | 'center';
                                                                                                                                                                                                                                                                                              direction?: 'horizontal' | 'vertical';
                                                                                                                                                                                                                                                                                              children?: ReactNode;
                                                                                                                                                                                                                                                                                              } & NativeProps;

                                                                                                                                                                                                                                                                                                type DotLoadingProps

                                                                                                                                                                                                                                                                                                type DotLoadingProps = {
                                                                                                                                                                                                                                                                                                color?: 'default' | 'primary' | 'white' | (string & {});
                                                                                                                                                                                                                                                                                                } & NativeProps;
                                                                                                                                                                                                                                                                                                  type DropdownItemProps = {
                                                                                                                                                                                                                                                                                                  key: string;
                                                                                                                                                                                                                                                                                                  title: ReactNode;
                                                                                                                                                                                                                                                                                                  active?: boolean;
                                                                                                                                                                                                                                                                                                  highlight?: boolean;
                                                                                                                                                                                                                                                                                                  forceRender?: boolean;
                                                                                                                                                                                                                                                                                                  destroyOnClose?: boolean;
                                                                                                                                                                                                                                                                                                  onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                  arrow?: ReactNode;
                                                                                                                                                                                                                                                                                                  children?: ReactNode;
                                                                                                                                                                                                                                                                                                  } & NativeProps;
                                                                                                                                                                                                                                                                                                    type DropdownProps = {
                                                                                                                                                                                                                                                                                                    activeKey?: string | null;
                                                                                                                                                                                                                                                                                                    defaultActiveKey?: string | null;
                                                                                                                                                                                                                                                                                                    closeOnMaskClick?: boolean;
                                                                                                                                                                                                                                                                                                    closeOnClickAway?: boolean;
                                                                                                                                                                                                                                                                                                    onChange?: (key: string | null) => void;
                                                                                                                                                                                                                                                                                                    arrow?: ReactNode;
                                                                                                                                                                                                                                                                                                    getContainer?: PopupProps['getContainer'];
                                                                                                                                                                                                                                                                                                    } & NativeProps;
                                                                                                                                                                                                                                                                                                      type DropdownRef = {
                                                                                                                                                                                                                                                                                                      close: () => void;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        type EllipsisProps

                                                                                                                                                                                                                                                                                                        type EllipsisProps = {
                                                                                                                                                                                                                                                                                                        content: string;
                                                                                                                                                                                                                                                                                                        direction?: 'start' | 'end' | 'middle';
                                                                                                                                                                                                                                                                                                        rows?: number;
                                                                                                                                                                                                                                                                                                        expandText?: ReactNode;
                                                                                                                                                                                                                                                                                                        collapseText?: ReactNode;
                                                                                                                                                                                                                                                                                                        stopPropagationForActionButtons?: PropagationEvent[];
                                                                                                                                                                                                                                                                                                        onContentClick?: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                        defaultExpanded?: boolean;
                                                                                                                                                                                                                                                                                                        } & NativeProps;

                                                                                                                                                                                                                                                                                                          type EmptyProps

                                                                                                                                                                                                                                                                                                          type EmptyProps = {
                                                                                                                                                                                                                                                                                                          image?: ReactNode;
                                                                                                                                                                                                                                                                                                          imageStyle?: CSSProperties;
                                                                                                                                                                                                                                                                                                          description?: ReactNode;
                                                                                                                                                                                                                                                                                                          } & NativeProps;

                                                                                                                                                                                                                                                                                                            type ErrorBlockProps

                                                                                                                                                                                                                                                                                                            type ErrorBlockProps = {
                                                                                                                                                                                                                                                                                                            status?: ErrorBlockStatus;
                                                                                                                                                                                                                                                                                                            title?: ReactNode;
                                                                                                                                                                                                                                                                                                            image?: string | ReactElement;
                                                                                                                                                                                                                                                                                                            description?: ReactNode;
                                                                                                                                                                                                                                                                                                            fullPage?: boolean;
                                                                                                                                                                                                                                                                                                            children?: ReactNode;
                                                                                                                                                                                                                                                                                                            } & NativeProps<
                                                                                                                                                                                                                                                                                                            | '--image-height'
                                                                                                                                                                                                                                                                                                            | '--image-height-full-page'
                                                                                                                                                                                                                                                                                                            | '--image-width'
                                                                                                                                                                                                                                                                                                            | '--image-width-full-page'
                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                              type ErrorBlockStatus

                                                                                                                                                                                                                                                                                                              type ErrorBlockStatus = 'default' | 'disconnected' | 'empty' | 'busy';

                                                                                                                                                                                                                                                                                                                type FloatingBubbleProps

                                                                                                                                                                                                                                                                                                                type FloatingBubbleProps = {
                                                                                                                                                                                                                                                                                                                onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                                axis?: 'x' | 'y' | 'xy' | 'lock';
                                                                                                                                                                                                                                                                                                                magnetic?: 'x' | 'y';
                                                                                                                                                                                                                                                                                                                children?: ReactNode;
                                                                                                                                                                                                                                                                                                                offset?: Offset;
                                                                                                                                                                                                                                                                                                                defaultOffset?: Offset;
                                                                                                                                                                                                                                                                                                                onOffsetChange?: (offset: Offset) => void;
                                                                                                                                                                                                                                                                                                                } & NativeProps<
                                                                                                                                                                                                                                                                                                                | '--initial-position-left'
                                                                                                                                                                                                                                                                                                                | '--initial-position-right'
                                                                                                                                                                                                                                                                                                                | '--initial-position-top'
                                                                                                                                                                                                                                                                                                                | '--initial-position-bottom'
                                                                                                                                                                                                                                                                                                                | '--z-index'
                                                                                                                                                                                                                                                                                                                | '--edge-distance'
                                                                                                                                                                                                                                                                                                                | '--size'
                                                                                                                                                                                                                                                                                                                | '--border-radius'
                                                                                                                                                                                                                                                                                                                | '--background'
                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                  type FloatingPanelProps

                                                                                                                                                                                                                                                                                                                  type FloatingPanelProps = {
                                                                                                                                                                                                                                                                                                                  anchors: number[];
                                                                                                                                                                                                                                                                                                                  children: ReactNode;
                                                                                                                                                                                                                                                                                                                  onHeightChange?: (height: number, animating: boolean) => void;
                                                                                                                                                                                                                                                                                                                  handleDraggingOfContent?: boolean;
                                                                                                                                                                                                                                                                                                                  } & NativeProps<'--border-radius' | '--z-index' | '--header-height'>;

                                                                                                                                                                                                                                                                                                                    type FloatingPanelRef

                                                                                                                                                                                                                                                                                                                    type FloatingPanelRef = {
                                                                                                                                                                                                                                                                                                                    setHeight: (
                                                                                                                                                                                                                                                                                                                    height: number,
                                                                                                                                                                                                                                                                                                                    options?: {
                                                                                                                                                                                                                                                                                                                    immediate?: boolean;
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                      type FooterProps

                                                                                                                                                                                                                                                                                                                      type FooterProps = {
                                                                                                                                                                                                                                                                                                                      label?: ReactNode;
                                                                                                                                                                                                                                                                                                                      links?: LinkItem[];
                                                                                                                                                                                                                                                                                                                      content?: ReactNode;
                                                                                                                                                                                                                                                                                                                      chips?: ChipItem[];
                                                                                                                                                                                                                                                                                                                      onChipClick?: (item: ChipItem, index: number) => void;
                                                                                                                                                                                                                                                                                                                      onLinkClick?: (item: LinkItem, index: number) => void;
                                                                                                                                                                                                                                                                                                                      } & NativeProps<'--background-color'>;

                                                                                                                                                                                                                                                                                                                        type FormItemProps

                                                                                                                                                                                                                                                                                                                        type FormItemProps = Pick<
                                                                                                                                                                                                                                                                                                                        RcFieldProps,
                                                                                                                                                                                                                                                                                                                        | 'dependencies'
                                                                                                                                                                                                                                                                                                                        | 'valuePropName'
                                                                                                                                                                                                                                                                                                                        | 'name'
                                                                                                                                                                                                                                                                                                                        | 'rules'
                                                                                                                                                                                                                                                                                                                        | 'messageVariables'
                                                                                                                                                                                                                                                                                                                        | 'trigger'
                                                                                                                                                                                                                                                                                                                        | 'validateTrigger'
                                                                                                                                                                                                                                                                                                                        | 'shouldUpdate'
                                                                                                                                                                                                                                                                                                                        | 'initialValue'
                                                                                                                                                                                                                                                                                                                        | 'getValueFromEvent'
                                                                                                                                                                                                                                                                                                                        | 'getValueProps'
                                                                                                                                                                                                                                                                                                                        | 'normalize'
                                                                                                                                                                                                                                                                                                                        | 'preserve'
                                                                                                                                                                                                                                                                                                                        | 'validateFirst'
                                                                                                                                                                                                                                                                                                                        > &
                                                                                                                                                                                                                                                                                                                        Pick<
                                                                                                                                                                                                                                                                                                                        ListItemProps,
                                                                                                                                                                                                                                                                                                                        'style' | 'extra' | 'clickable' | 'arrow' | 'description'
                                                                                                                                                                                                                                                                                                                        > & {
                                                                                                                                                                                                                                                                                                                        label?: ReactNode;
                                                                                                                                                                                                                                                                                                                        help?: ReactNode;
                                                                                                                                                                                                                                                                                                                        hasFeedback?: boolean;
                                                                                                                                                                                                                                                                                                                        required?: boolean;
                                                                                                                                                                                                                                                                                                                        noStyle?: boolean;
                                                                                                                                                                                                                                                                                                                        disabled?: boolean;
                                                                                                                                                                                                                                                                                                                        hidden?: boolean;
                                                                                                                                                                                                                                                                                                                        layout?: FormLayout;
                                                                                                                                                                                                                                                                                                                        childElementPosition?: 'normal' | 'right';
                                                                                                                                                                                                                                                                                                                        children?: ChildrenType;
                                                                                                                                                                                                                                                                                                                        onClick?: (e: React.MouseEvent, widgetRef: MutableRefObject<any>) => void;
                                                                                                                                                                                                                                                                                                                        } & NativeProps;

                                                                                                                                                                                                                                                                                                                          type FormProps

                                                                                                                                                                                                                                                                                                                          type FormProps = Pick<
                                                                                                                                                                                                                                                                                                                          RcFormProps,
                                                                                                                                                                                                                                                                                                                          | 'form'
                                                                                                                                                                                                                                                                                                                          | 'initialValues'
                                                                                                                                                                                                                                                                                                                          | 'name'
                                                                                                                                                                                                                                                                                                                          | 'preserve'
                                                                                                                                                                                                                                                                                                                          | 'validateMessages'
                                                                                                                                                                                                                                                                                                                          | 'validateTrigger'
                                                                                                                                                                                                                                                                                                                          | 'onFieldsChange'
                                                                                                                                                                                                                                                                                                                          | 'onFinish'
                                                                                                                                                                                                                                                                                                                          | 'onFinishFailed'
                                                                                                                                                                                                                                                                                                                          | 'onValuesChange'
                                                                                                                                                                                                                                                                                                                          | 'children'
                                                                                                                                                                                                                                                                                                                          > &
                                                                                                                                                                                                                                                                                                                          NativeProps<
                                                                                                                                                                                                                                                                                                                          '--border-inner' | '--border-top' | '--border-bottom' | '--prefix-width'
                                                                                                                                                                                                                                                                                                                          > &
                                                                                                                                                                                                                                                                                                                          Partial<FormContextType> & {
                                                                                                                                                                                                                                                                                                                          footer?: ReactNode;
                                                                                                                                                                                                                                                                                                                          mode?: ListProps['mode'];
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            type GridItemProps

                                                                                                                                                                                                                                                                                                                            type GridItemProps = {
                                                                                                                                                                                                                                                                                                                            span?: number;
                                                                                                                                                                                                                                                                                                                            onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                                            children?: ReactNode;
                                                                                                                                                                                                                                                                                                                            } & NativeProps;

                                                                                                                                                                                                                                                                                                                              type GridProps

                                                                                                                                                                                                                                                                                                                              type GridProps = {
                                                                                                                                                                                                                                                                                                                              columns: number;
                                                                                                                                                                                                                                                                                                                              gap?: number | string | [number | string, number | string];
                                                                                                                                                                                                                                                                                                                              children?: ReactNode;
                                                                                                                                                                                                                                                                                                                              } & NativeProps<'--gap' | '--gap-vertical' | '--gap-horizontal'>;

                                                                                                                                                                                                                                                                                                                                type ImageProps

                                                                                                                                                                                                                                                                                                                                type ImageProps = {
                                                                                                                                                                                                                                                                                                                                src?: string;
                                                                                                                                                                                                                                                                                                                                alt?: string;
                                                                                                                                                                                                                                                                                                                                width?: number | string;
                                                                                                                                                                                                                                                                                                                                height?: number | string;
                                                                                                                                                                                                                                                                                                                                fit?: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
                                                                                                                                                                                                                                                                                                                                placeholder?: ReactNode;
                                                                                                                                                                                                                                                                                                                                fallback?: ReactNode;
                                                                                                                                                                                                                                                                                                                                lazy?: boolean;
                                                                                                                                                                                                                                                                                                                                draggable?: boolean;
                                                                                                                                                                                                                                                                                                                                onClick?: (event: React.MouseEvent<HTMLImageElement, Event>) => void;
                                                                                                                                                                                                                                                                                                                                onError?: (event: React.SyntheticEvent<HTMLImageElement, Event>) => void;
                                                                                                                                                                                                                                                                                                                                onLoad?: (event: React.SyntheticEvent<HTMLImageElement, Event>) => void;
                                                                                                                                                                                                                                                                                                                                onContainerClick?: (event: React.MouseEvent<HTMLDivElement, Event>) => void;
                                                                                                                                                                                                                                                                                                                                } & NativeProps<'--width' | '--height'> &
                                                                                                                                                                                                                                                                                                                                Pick<
                                                                                                                                                                                                                                                                                                                                React.ImgHTMLAttributes<HTMLImageElement>,
                                                                                                                                                                                                                                                                                                                                | 'crossOrigin'
                                                                                                                                                                                                                                                                                                                                | 'decoding'
                                                                                                                                                                                                                                                                                                                                | 'loading'
                                                                                                                                                                                                                                                                                                                                | 'referrerPolicy'
                                                                                                                                                                                                                                                                                                                                | 'sizes'
                                                                                                                                                                                                                                                                                                                                | 'srcSet'
                                                                                                                                                                                                                                                                                                                                | 'useMap'
                                                                                                                                                                                                                                                                                                                                | 'id'
                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                  type ImageUploaderProps

                                                                                                                                                                                                                                                                                                                                  type ImageUploaderProps = {
                                                                                                                                                                                                                                                                                                                                  defaultValue?: ImageUploadItem[];
                                                                                                                                                                                                                                                                                                                                  value?: ImageUploadItem[];
                                                                                                                                                                                                                                                                                                                                  columns?: GridProps['columns'];
                                                                                                                                                                                                                                                                                                                                  onChange?: (items: ImageUploadItem[]) => void;
                                                                                                                                                                                                                                                                                                                                  onUploadQueueChange?: (tasks: UploadTask[]) => void;
                                                                                                                                                                                                                                                                                                                                  accept?: string;
                                                                                                                                                                                                                                                                                                                                  multiple?: boolean;
                                                                                                                                                                                                                                                                                                                                  maxCount?: number;
                                                                                                                                                                                                                                                                                                                                  onCountExceed?: (exceed: number) => void;
                                                                                                                                                                                                                                                                                                                                  disableUpload?: boolean;
                                                                                                                                                                                                                                                                                                                                  showUpload?: boolean;
                                                                                                                                                                                                                                                                                                                                  deletable?: boolean;
                                                                                                                                                                                                                                                                                                                                  deleteIcon?: ReactNode;
                                                                                                                                                                                                                                                                                                                                  capture?: InputHTMLAttributes<unknown>['capture'];
                                                                                                                                                                                                                                                                                                                                  onPreview?: (index: number, item: ImageUploadItem) => void;
                                                                                                                                                                                                                                                                                                                                  beforeUpload?: (file: File, files: File[]) => Promise<File | null> | File | null;
                                                                                                                                                                                                                                                                                                                                  upload: (file: File) => Promise<ImageUploadItem>;
                                                                                                                                                                                                                                                                                                                                  onDelete?: (item: ImageUploadItem) => boolean | Promise<boolean> | void;
                                                                                                                                                                                                                                                                                                                                  preview?: boolean;
                                                                                                                                                                                                                                                                                                                                  showFailed?: boolean;
                                                                                                                                                                                                                                                                                                                                  imageFit?: ImageProps['fit'];
                                                                                                                                                                                                                                                                                                                                  children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                  renderItem?: (
                                                                                                                                                                                                                                                                                                                                  originNode: ReactElement,
                                                                                                                                                                                                                                                                                                                                  file: ImageUploadItem,
                                                                                                                                                                                                                                                                                                                                  fileList: ImageUploadItem[]
                                                                                                                                                                                                                                                                                                                                  ) => ReactNode;
                                                                                                                                                                                                                                                                                                                                  } & NativeProps<'--cell-size' | '--gap' | '--gap-vertical' | '--gap-horizontal'>;

                                                                                                                                                                                                                                                                                                                                    type ImageViewerProps

                                                                                                                                                                                                                                                                                                                                    type ImageViewerProps = {
                                                                                                                                                                                                                                                                                                                                    image?: string;
                                                                                                                                                                                                                                                                                                                                    maxZoom?: number | 'auto';
                                                                                                                                                                                                                                                                                                                                    getContainer?: GetContainer;
                                                                                                                                                                                                                                                                                                                                    visible?: boolean;
                                                                                                                                                                                                                                                                                                                                    onClose?: () => void;
                                                                                                                                                                                                                                                                                                                                    afterClose?: () => void;
                                                                                                                                                                                                                                                                                                                                    renderFooter?: (image: string) => ReactNode;
                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                      type IndexBarPanelProps

                                                                                                                                                                                                                                                                                                                                      type IndexBarPanelProps = {
                                                                                                                                                                                                                                                                                                                                      index: string;
                                                                                                                                                                                                                                                                                                                                      title?: ReactNode;
                                                                                                                                                                                                                                                                                                                                      brief?: ReactNode;
                                                                                                                                                                                                                                                                                                                                      children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                      } & NativeProps;

                                                                                                                                                                                                                                                                                                                                        type IndexBarProps

                                                                                                                                                                                                                                                                                                                                        type IndexBarProps = {
                                                                                                                                                                                                                                                                                                                                        sticky?: boolean;
                                                                                                                                                                                                                                                                                                                                        onIndexChange?: (index: string) => void;
                                                                                                                                                                                                                                                                                                                                        children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                        } & NativeProps<'--sticky-offset-top'>;

                                                                                                                                                                                                                                                                                                                                          type IndexBarRef

                                                                                                                                                                                                                                                                                                                                          type IndexBarRef = {
                                                                                                                                                                                                                                                                                                                                          scrollTo: (index: string) => void;
                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                            type InfiniteScrollProps

                                                                                                                                                                                                                                                                                                                                            type InfiniteScrollProps = {
                                                                                                                                                                                                                                                                                                                                            loadMore: (isRetry: boolean) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                            hasMore: boolean;
                                                                                                                                                                                                                                                                                                                                            threshold?: number;
                                                                                                                                                                                                                                                                                                                                            children?:
                                                                                                                                                                                                                                                                                                                                            | ReactNode
                                                                                                                                                                                                                                                                                                                                            | ((hasMore: boolean, failed: boolean, retry: () => void) => ReactNode);
                                                                                                                                                                                                                                                                                                                                            } & NativeProps;

                                                                                                                                                                                                                                                                                                                                              type InputProps

                                                                                                                                                                                                                                                                                                                                              type InputProps = Pick<
                                                                                                                                                                                                                                                                                                                                              NativeInputProps,
                                                                                                                                                                                                                                                                                                                                              | 'maxLength'
                                                                                                                                                                                                                                                                                                                                              | 'minLength'
                                                                                                                                                                                                                                                                                                                                              | 'autoComplete'
                                                                                                                                                                                                                                                                                                                                              | 'autoFocus'
                                                                                                                                                                                                                                                                                                                                              | 'pattern'
                                                                                                                                                                                                                                                                                                                                              | 'inputMode'
                                                                                                                                                                                                                                                                                                                                              | 'type'
                                                                                                                                                                                                                                                                                                                                              | 'name'
                                                                                                                                                                                                                                                                                                                                              | 'onFocus'
                                                                                                                                                                                                                                                                                                                                              | 'onBlur'
                                                                                                                                                                                                                                                                                                                                              | 'autoCapitalize'
                                                                                                                                                                                                                                                                                                                                              | 'autoCorrect'
                                                                                                                                                                                                                                                                                                                                              | 'onKeyDown'
                                                                                                                                                                                                                                                                                                                                              | 'onKeyUp'
                                                                                                                                                                                                                                                                                                                                              | 'onCompositionStart'
                                                                                                                                                                                                                                                                                                                                              | 'onCompositionEnd'
                                                                                                                                                                                                                                                                                                                                              | 'onClick'
                                                                                                                                                                                                                                                                                                                                              | 'step'
                                                                                                                                                                                                                                                                                                                                              | 'id'
                                                                                                                                                                                                                                                                                                                                              | 'placeholder'
                                                                                                                                                                                                                                                                                                                                              | 'readOnly'
                                                                                                                                                                                                                                                                                                                                              | 'disabled'
                                                                                                                                                                                                                                                                                                                                              > & {
                                                                                                                                                                                                                                                                                                                                              value?: string;
                                                                                                                                                                                                                                                                                                                                              defaultValue?: string;
                                                                                                                                                                                                                                                                                                                                              onChange?: (val: string) => void;
                                                                                                                                                                                                                                                                                                                                              clearable?: boolean;
                                                                                                                                                                                                                                                                                                                                              onlyShowClearWhenFocus?: boolean;
                                                                                                                                                                                                                                                                                                                                              onClear?: () => void;
                                                                                                                                                                                                                                                                                                                                              onEnterPress?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
                                                                                                                                                                                                                                                                                                                                              enterKeyHint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
                                                                                                                                                                                                                                                                                                                                              min?: number;
                                                                                                                                                                                                                                                                                                                                              max?: number;
                                                                                                                                                                                                                                                                                                                                              } & NativeProps<'--font-size' | '--color' | '--placeholder-color' | '--text-align'> &
                                                                                                                                                                                                                                                                                                                                              AriaProps;

                                                                                                                                                                                                                                                                                                                                                type InputRef

                                                                                                                                                                                                                                                                                                                                                type InputRef = {
                                                                                                                                                                                                                                                                                                                                                clear: () => void;
                                                                                                                                                                                                                                                                                                                                                focus: () => void;
                                                                                                                                                                                                                                                                                                                                                blur: () => void;
                                                                                                                                                                                                                                                                                                                                                nativeElement: HTMLInputElement | null;
                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                  type JumboTabProps

                                                                                                                                                                                                                                                                                                                                                  type JumboTabProps = {
                                                                                                                                                                                                                                                                                                                                                  title: ReactNode;
                                                                                                                                                                                                                                                                                                                                                  description: ReactNode;
                                                                                                                                                                                                                                                                                                                                                  disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                  forceRender?: boolean;
                                                                                                                                                                                                                                                                                                                                                  destroyOnClose?: boolean;
                                                                                                                                                                                                                                                                                                                                                  children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                  } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                    type JumboTabsProps

                                                                                                                                                                                                                                                                                                                                                    type JumboTabsProps = {
                                                                                                                                                                                                                                                                                                                                                    activeKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                    defaultActiveKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                    onChange?: (key: string) => void;
                                                                                                                                                                                                                                                                                                                                                    children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                    } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                      type ListItemProps

                                                                                                                                                                                                                                                                                                                                                      type ListItemProps = {
                                                                                                                                                                                                                                                                                                                                                      title?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                      children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                      description?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                      prefix?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                      extra?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                      clickable?: boolean;
                                                                                                                                                                                                                                                                                                                                                      arrow?: boolean | ReactNode;
                                                                                                                                                                                                                                                                                                                                                      disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                      onClick?: (e: React.MouseEvent<HTMLElement>) => void;
                                                                                                                                                                                                                                                                                                                                                      } & NativeProps<'--prefix-width' | '--align-items' | '--active-background-color'>;

                                                                                                                                                                                                                                                                                                                                                        type ListProps

                                                                                                                                                                                                                                                                                                                                                        type ListProps = {
                                                                                                                                                                                                                                                                                                                                                        header?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                        mode?: 'default' | 'card';
                                                                                                                                                                                                                                                                                                                                                        children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                        } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                        | '--active-background-color'
                                                                                                                                                                                                                                                                                                                                                        | '--align-items'
                                                                                                                                                                                                                                                                                                                                                        | '--border-bottom'
                                                                                                                                                                                                                                                                                                                                                        | '--border-inner'
                                                                                                                                                                                                                                                                                                                                                        | '--border-top'
                                                                                                                                                                                                                                                                                                                                                        | '--extra-max-width'
                                                                                                                                                                                                                                                                                                                                                        | '--font-size'
                                                                                                                                                                                                                                                                                                                                                        | '--header-font-size'
                                                                                                                                                                                                                                                                                                                                                        | '--padding-left'
                                                                                                                                                                                                                                                                                                                                                        | '--padding-right'
                                                                                                                                                                                                                                                                                                                                                        | '--prefix-padding-right'
                                                                                                                                                                                                                                                                                                                                                        | '--prefix-width'
                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                          type ListRef

                                                                                                                                                                                                                                                                                                                                                          type ListRef = {
                                                                                                                                                                                                                                                                                                                                                          nativeElement: HTMLDivElement | null;
                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                            type LoadingProps

                                                                                                                                                                                                                                                                                                                                                            type LoadingProps = DotLoadingProps;

                                                                                                                                                                                                                                                                                                                                                              type MaskProps

                                                                                                                                                                                                                                                                                                                                                              type MaskProps = {
                                                                                                                                                                                                                                                                                                                                                              visible?: boolean;
                                                                                                                                                                                                                                                                                                                                                              onMaskClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                                                                              destroyOnClose?: boolean;
                                                                                                                                                                                                                                                                                                                                                              forceRender?: boolean;
                                                                                                                                                                                                                                                                                                                                                              disableBodyScroll?: boolean;
                                                                                                                                                                                                                                                                                                                                                              color?: 'white' | 'black' | (string & {});
                                                                                                                                                                                                                                                                                                                                                              opacity?: 'default' | 'thin' | 'thick' | number;
                                                                                                                                                                                                                                                                                                                                                              getContainer?: GetContainer;
                                                                                                                                                                                                                                                                                                                                                              afterShow?: () => void;
                                                                                                                                                                                                                                                                                                                                                              afterClose?: () => void;
                                                                                                                                                                                                                                                                                                                                                              stopPropagation?: PropagationEvent[];
                                                                                                                                                                                                                                                                                                                                                              children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                              } & NativeProps<'--z-index'>;

                                                                                                                                                                                                                                                                                                                                                                type ModalAlertProps

                                                                                                                                                                                                                                                                                                                                                                type ModalAlertProps = Omit<ModalProps, 'visible' | 'closeOnAction' | 'actions'> & {
                                                                                                                                                                                                                                                                                                                                                                confirmText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                onConfirm?: () => void | Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                  type ModalConfirmProps

                                                                                                                                                                                                                                                                                                                                                                  type ModalConfirmProps = Omit<
                                                                                                                                                                                                                                                                                                                                                                  ModalProps,
                                                                                                                                                                                                                                                                                                                                                                  'visible' | 'closeOnAction' | 'actions'
                                                                                                                                                                                                                                                                                                                                                                  > & {
                                                                                                                                                                                                                                                                                                                                                                  confirmText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                  cancelText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                  onConfirm?: () => void | Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                  onCancel?: () => void | Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                    type ModalProps

                                                                                                                                                                                                                                                                                                                                                                    type ModalProps = Pick<
                                                                                                                                                                                                                                                                                                                                                                    CenterPopupProps,
                                                                                                                                                                                                                                                                                                                                                                    | 'afterClose'
                                                                                                                                                                                                                                                                                                                                                                    | 'afterShow'
                                                                                                                                                                                                                                                                                                                                                                    | 'bodyClassName'
                                                                                                                                                                                                                                                                                                                                                                    | 'bodyStyle'
                                                                                                                                                                                                                                                                                                                                                                    | 'destroyOnClose'
                                                                                                                                                                                                                                                                                                                                                                    | 'disableBodyScroll'
                                                                                                                                                                                                                                                                                                                                                                    | 'forceRender'
                                                                                                                                                                                                                                                                                                                                                                    | 'getContainer'
                                                                                                                                                                                                                                                                                                                                                                    | 'maskClassName'
                                                                                                                                                                                                                                                                                                                                                                    | 'maskStyle'
                                                                                                                                                                                                                                                                                                                                                                    | 'stopPropagation'
                                                                                                                                                                                                                                                                                                                                                                    | 'visible'
                                                                                                                                                                                                                                                                                                                                                                    > & {
                                                                                                                                                                                                                                                                                                                                                                    image?: string;
                                                                                                                                                                                                                                                                                                                                                                    header?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                    title?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                    content?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                    actions?: Action[];
                                                                                                                                                                                                                                                                                                                                                                    onAction?: (action: Action, index: number) => void | Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    onClose?: () => void;
                                                                                                                                                                                                                                                                                                                                                                    closeOnAction?: boolean;
                                                                                                                                                                                                                                                                                                                                                                    closeOnMaskClick?: boolean;
                                                                                                                                                                                                                                                                                                                                                                    showCloseButton?: boolean;
                                                                                                                                                                                                                                                                                                                                                                    } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                      type ModalShowProps

                                                                                                                                                                                                                                                                                                                                                                      type ModalShowProps = Omit<ModalProps, 'visible' | 'destroyOnClose' | 'forceRender'>;

                                                                                                                                                                                                                                                                                                                                                                        type MultiImageViewerProps

                                                                                                                                                                                                                                                                                                                                                                        type MultiImageViewerProps = Omit<ImageViewerProps, 'image' | 'renderFooter'> & {
                                                                                                                                                                                                                                                                                                                                                                        images?: string[];
                                                                                                                                                                                                                                                                                                                                                                        defaultIndex?: number;
                                                                                                                                                                                                                                                                                                                                                                        onIndexChange?: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                        renderFooter?: (image: string, index: number) => ReactNode;
                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                          type MultiImageViewerRef

                                                                                                                                                                                                                                                                                                                                                                          type MultiImageViewerRef = SlidesRef;
                                                                                                                                                                                                                                                                                                                                                                            type NavBarProps = {
                                                                                                                                                                                                                                                                                                                                                                            back?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                            backArrow?: boolean | ReactNode;
                                                                                                                                                                                                                                                                                                                                                                            left?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                            right?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                            onBack?: () => void;
                                                                                                                                                                                                                                                                                                                                                                            children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                            } & NativeProps<'--height' | '--border-bottom'>;

                                                                                                                                                                                                                                                                                                                                                                              type NoticeBarProps

                                                                                                                                                                                                                                                                                                                                                                              type NoticeBarProps = {
                                                                                                                                                                                                                                                                                                                                                                              /** The type of the NoticeBar */
                                                                                                                                                                                                                                                                                                                                                                              color?: 'default' | 'alert' | 'error' | 'info';
                                                                                                                                                                                                                                                                                                                                                                              /** TDelay to start scrolling, unit ms */
                                                                                                                                                                                                                                                                                                                                                                              delay?: number;
                                                                                                                                                                                                                                                                                                                                                                              /** Scroll speed, unit px/s */
                                                                                                                                                                                                                                                                                                                                                                              speed?: number;
                                                                                                                                                                                                                                                                                                                                                                              /** The content of the NoticeBar */
                                                                                                                                                                                                                                                                                                                                                                              content: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                              /** Whether it can be closed */
                                                                                                                                                                                                                                                                                                                                                                              closeable?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              /** Callback when closed */
                                                                                                                                                                                                                                                                                                                                                                              onClose?: () => void;
                                                                                                                                                                                                                                                                                                                                                                              /** Event when click */
                                                                                                                                                                                                                                                                                                                                                                              onClick?: () => void;
                                                                                                                                                                                                                                                                                                                                                                              /** Additional operating area, displayed to the left of the close button */
                                                                                                                                                                                                                                                                                                                                                                              extra?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                              /** Radio icon on the left */
                                                                                                                                                                                                                                                                                                                                                                              icon?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                              /** Whether to display multiple lines */
                                                                                                                                                                                                                                                                                                                                                                              wrap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                              | '--background-color'
                                                                                                                                                                                                                                                                                                                                                                              | '--border-color'
                                                                                                                                                                                                                                                                                                                                                                              | '--text-color'
                                                                                                                                                                                                                                                                                                                                                                              | '--font-size'
                                                                                                                                                                                                                                                                                                                                                                              | '--icon-font-size'
                                                                                                                                                                                                                                                                                                                                                                              | '--height'
                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                type NumberKeyboardProps

                                                                                                                                                                                                                                                                                                                                                                                type NumberKeyboardProps = {
                                                                                                                                                                                                                                                                                                                                                                                visible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                title?: string;
                                                                                                                                                                                                                                                                                                                                                                                confirmText?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                customKey?: string | [string, string];
                                                                                                                                                                                                                                                                                                                                                                                randomOrder?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                showCloseButton?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                onInput?: (v: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                onDelete?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                onClose?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                onConfirm?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                closeOnConfirm?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                safeArea?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                } & Pick<
                                                                                                                                                                                                                                                                                                                                                                                PopupProps,
                                                                                                                                                                                                                                                                                                                                                                                | 'afterClose'
                                                                                                                                                                                                                                                                                                                                                                                | 'afterShow'
                                                                                                                                                                                                                                                                                                                                                                                | 'getContainer'
                                                                                                                                                                                                                                                                                                                                                                                | 'destroyOnClose'
                                                                                                                                                                                                                                                                                                                                                                                | 'forceRender'
                                                                                                                                                                                                                                                                                                                                                                                | 'stopPropagation'
                                                                                                                                                                                                                                                                                                                                                                                > &
                                                                                                                                                                                                                                                                                                                                                                                NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                  type PageIndicatorProps

                                                                                                                                                                                                                                                                                                                                                                                  type PageIndicatorProps = {
                                                                                                                                                                                                                                                                                                                                                                                  total: number;
                                                                                                                                                                                                                                                                                                                                                                                  current: number;
                                                                                                                                                                                                                                                                                                                                                                                  direction?: 'horizontal' | 'vertical';
                                                                                                                                                                                                                                                                                                                                                                                  color?: 'primary' | 'white';
                                                                                                                                                                                                                                                                                                                                                                                  } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                  | '--dot-color'
                                                                                                                                                                                                                                                                                                                                                                                  | '--active-dot-color'
                                                                                                                                                                                                                                                                                                                                                                                  | '--dot-size'
                                                                                                                                                                                                                                                                                                                                                                                  | '--active-dot-size'
                                                                                                                                                                                                                                                                                                                                                                                  | '--dot-border-radius'
                                                                                                                                                                                                                                                                                                                                                                                  | '--active-dot-border-radius'
                                                                                                                                                                                                                                                                                                                                                                                  | '--dot-spacing'
                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                    type PasscodeInputProps

                                                                                                                                                                                                                                                                                                                                                                                    type PasscodeInputProps = {
                                                                                                                                                                                                                                                                                                                                                                                    value?: string;
                                                                                                                                                                                                                                                                                                                                                                                    defaultValue?: string;
                                                                                                                                                                                                                                                                                                                                                                                    onChange?: (val: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                    length?: number;
                                                                                                                                                                                                                                                                                                                                                                                    plain?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                    error?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                    caret?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                    seperated?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                    onBlur?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                    onFocus?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                    keyboard?: ReactElement<NumberKeyboardProps>;
                                                                                                                                                                                                                                                                                                                                                                                    onFill?: (val: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                    } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                    | '--cell-gap'
                                                                                                                                                                                                                                                                                                                                                                                    | '--cell-size'
                                                                                                                                                                                                                                                                                                                                                                                    | '--dot-size'
                                                                                                                                                                                                                                                                                                                                                                                    | '--border-color'
                                                                                                                                                                                                                                                                                                                                                                                    | '--border-radius'
                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                      type PasscodeInputRef

                                                                                                                                                                                                                                                                                                                                                                                      type PasscodeInputRef = {
                                                                                                                                                                                                                                                                                                                                                                                      focus: () => void;
                                                                                                                                                                                                                                                                                                                                                                                      blur: () => void;
                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                        type PickerProps

                                                                                                                                                                                                                                                                                                                                                                                        type PickerProps = {
                                                                                                                                                                                                                                                                                                                                                                                        columns: PickerColumn[] | ((value: PickerValue[]) => PickerColumn[]);
                                                                                                                                                                                                                                                                                                                                                                                        value?: PickerValue[];
                                                                                                                                                                                                                                                                                                                                                                                        defaultValue?: PickerValue[];
                                                                                                                                                                                                                                                                                                                                                                                        loading?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                        loadingContent?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                        onSelect?: (value: PickerValue[], extend: PickerValueExtend) => void;
                                                                                                                                                                                                                                                                                                                                                                                        onConfirm?: (value: PickerValue[], extend: PickerValueExtend) => void;
                                                                                                                                                                                                                                                                                                                                                                                        onCancel?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                        onClose?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                        closeOnMaskClick?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                        visible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                        title?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                        confirmText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                        cancelText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                        children?: (
                                                                                                                                                                                                                                                                                                                                                                                        items: (PickerColumnItem | null)[],
                                                                                                                                                                                                                                                                                                                                                                                        actions: PickerActions
                                                                                                                                                                                                                                                                                                                                                                                        ) => ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                        renderLabel?: (item: PickerColumnItem) => ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                        mouseWheel?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                        popupClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                        popupStyle?: CSSProperties;
                                                                                                                                                                                                                                                                                                                                                                                        } & Pick<
                                                                                                                                                                                                                                                                                                                                                                                        PopupProps,
                                                                                                                                                                                                                                                                                                                                                                                        | 'getContainer'
                                                                                                                                                                                                                                                                                                                                                                                        | 'afterShow'
                                                                                                                                                                                                                                                                                                                                                                                        | 'afterClose'
                                                                                                                                                                                                                                                                                                                                                                                        | 'onClick'
                                                                                                                                                                                                                                                                                                                                                                                        | 'stopPropagation'
                                                                                                                                                                                                                                                                                                                                                                                        | 'forceRender'
                                                                                                                                                                                                                                                                                                                                                                                        | 'destroyOnClose'
                                                                                                                                                                                                                                                                                                                                                                                        > &
                                                                                                                                                                                                                                                                                                                                                                                        NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                        | '--header-button-font-size'
                                                                                                                                                                                                                                                                                                                                                                                        | '--title-font-size'
                                                                                                                                                                                                                                                                                                                                                                                        | '--item-font-size'
                                                                                                                                                                                                                                                                                                                                                                                        | '--item-height'
                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                          type PickerRef

                                                                                                                                                                                                                                                                                                                                                                                          type PickerRef = PickerActions;

                                                                                                                                                                                                                                                                                                                                                                                            type PickerViewProps

                                                                                                                                                                                                                                                                                                                                                                                            type PickerViewProps = {
                                                                                                                                                                                                                                                                                                                                                                                            columns: PickerColumn[] | ((value: PickerValue[]) => PickerColumn[]);
                                                                                                                                                                                                                                                                                                                                                                                            value?: PickerValue[];
                                                                                                                                                                                                                                                                                                                                                                                            defaultValue?: PickerValue[];
                                                                                                                                                                                                                                                                                                                                                                                            mouseWheel?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                            loading?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                            loadingContent?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                            onChange?: (value: PickerValue[], extend: PickerValueExtend) => void;
                                                                                                                                                                                                                                                                                                                                                                                            } & Pick<PickerProps, 'renderLabel'> &
                                                                                                                                                                                                                                                                                                                                                                                            NativeProps<'--height' | '--item-height' | '--item-font-size'>;

                                                                                                                                                                                                                                                                                                                                                                                              type PopoverMenuProps

                                                                                                                                                                                                                                                                                                                                                                                              type PopoverMenuProps = Omit<PopoverProps, 'content'> & {
                                                                                                                                                                                                                                                                                                                                                                                              actions: Action[];
                                                                                                                                                                                                                                                                                                                                                                                              maxCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                              onAction?: (item: Action) => void;
                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                type PopoverProps

                                                                                                                                                                                                                                                                                                                                                                                                type PopoverProps = {
                                                                                                                                                                                                                                                                                                                                                                                                defaultVisible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                visible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                onVisibleChange?: (visible: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                getContainer?: GetContainer;
                                                                                                                                                                                                                                                                                                                                                                                                destroyOnHide?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                children: ReactElement;
                                                                                                                                                                                                                                                                                                                                                                                                mode?: 'light' | 'dark';
                                                                                                                                                                                                                                                                                                                                                                                                trigger?: 'click';
                                                                                                                                                                                                                                                                                                                                                                                                placement?: Placement | DeprecatedPlacement;
                                                                                                                                                                                                                                                                                                                                                                                                stopPropagation?: PropagationEvent[];
                                                                                                                                                                                                                                                                                                                                                                                                content: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                } & NativeProps<'--z-index' | '--arrow-size'>;

                                                                                                                                                                                                                                                                                                                                                                                                  type PopoverRef

                                                                                                                                                                                                                                                                                                                                                                                                  type PopoverRef = {
                                                                                                                                                                                                                                                                                                                                                                                                  show: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                  hide: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                  visible: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                    type PopupProps

                                                                                                                                                                                                                                                                                                                                                                                                    type PopupProps = PopupBaseProps &
                                                                                                                                                                                                                                                                                                                                                                                                    PropsWithChildren<{
                                                                                                                                                                                                                                                                                                                                                                                                    position?: 'bottom' | 'top' | 'left' | 'right';
                                                                                                                                                                                                                                                                                                                                                                                                    closeOnSwipe?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                    }> &
                                                                                                                                                                                                                                                                                                                                                                                                    NativeProps<'--z-index'>;

                                                                                                                                                                                                                                                                                                                                                                                                      type ProgressBarProps

                                                                                                                                                                                                                                                                                                                                                                                                      type ProgressBarProps = {
                                                                                                                                                                                                                                                                                                                                                                                                      percent?: number;
                                                                                                                                                                                                                                                                                                                                                                                                      rounded?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                      text?: boolean | ReactNode | ((percent: number) => ReactNode);
                                                                                                                                                                                                                                                                                                                                                                                                      } & NativeProps<'--track-width' | '--track-color' | '--fill-color' | '--text-width'>;

                                                                                                                                                                                                                                                                                                                                                                                                        type ProgressCircleProps

                                                                                                                                                                                                                                                                                                                                                                                                        type ProgressCircleProps = {
                                                                                                                                                                                                                                                                                                                                                                                                        percent?: number;
                                                                                                                                                                                                                                                                                                                                                                                                        children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                        } & NativeProps<'--size' | '--track-width' | '--track-color' | '--fill-color'>;

                                                                                                                                                                                                                                                                                                                                                                                                          type PullToRefreshProps

                                                                                                                                                                                                                                                                                                                                                                                                          type PullToRefreshProps = {
                                                                                                                                                                                                                                                                                                                                                                                                          onRefresh?: () => Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                          pullingText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                          canReleaseText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                          refreshingText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                          completeText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                          completeDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                          headHeight?: number;
                                                                                                                                                                                                                                                                                                                                                                                                          threshold?: number;
                                                                                                                                                                                                                                                                                                                                                                                                          disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                          renderText?: (status: PullStatus) => ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                          children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                            type RadioProps

                                                                                                                                                                                                                                                                                                                                                                                                            type RadioProps = {
                                                                                                                                                                                                                                                                                                                                                                                                            checked?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                            defaultChecked?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                            disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                            onChange?: (checked: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                            value?: RadioValue;
                                                                                                                                                                                                                                                                                                                                                                                                            block?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                            id?: string;
                                                                                                                                                                                                                                                                                                                                                                                                            icon?: (checked: boolean) => ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                            children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                            onClick?: (event: React.MouseEvent<HTMLLabelElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                                                                                                                            } & NativeProps<'--icon-size' | '--font-size' | '--gap'>;

                                                                                                                                                                                                                                                                                                                                                                                                              type RateProps

                                                                                                                                                                                                                                                                                                                                                                                                              type RateProps = {
                                                                                                                                                                                                                                                                                                                                                                                                              allowClear?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                              allowHalf?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                              character?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                              count?: number;
                                                                                                                                                                                                                                                                                                                                                                                                              defaultValue?: number;
                                                                                                                                                                                                                                                                                                                                                                                                              readOnly?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                              value?: number;
                                                                                                                                                                                                                                                                                                                                                                                                              onChange?: (value: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                              } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                              '--star-size' | '--active-color' | '--inactive-color' | '--inactive-color-half'
                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                type ResultPageProps

                                                                                                                                                                                                                                                                                                                                                                                                                type ResultPageProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                status?: 'success' | 'error' | 'info' | 'waiting' | 'warning';
                                                                                                                                                                                                                                                                                                                                                                                                                title: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                description?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                icon?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                details?: ResultPageDetails | null;
                                                                                                                                                                                                                                                                                                                                                                                                                children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                primaryButtonText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                secondaryButtonText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                onPrimaryButtonClick?: OnClick;
                                                                                                                                                                                                                                                                                                                                                                                                                onSecondaryButtonClick?: OnClick;
                                                                                                                                                                                                                                                                                                                                                                                                                } & NativeProps<'--background-color'>;

                                                                                                                                                                                                                                                                                                                                                                                                                  type ResultProps

                                                                                                                                                                                                                                                                                                                                                                                                                  type ResultProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                  status?: 'success' | 'error' | 'info' | 'waiting' | 'warning';
                                                                                                                                                                                                                                                                                                                                                                                                                  title: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                  description?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                  icon?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                  } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                    type SafeAreaProps

                                                                                                                                                                                                                                                                                                                                                                                                                    type SafeAreaProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                    position: 'top' | 'bottom';
                                                                                                                                                                                                                                                                                                                                                                                                                    } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                      type ScrollMaskProps

                                                                                                                                                                                                                                                                                                                                                                                                                      type ScrollMaskProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                      scrollTrackRef: RefObject<HTMLElement>;
                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                        type SearchBarProps

                                                                                                                                                                                                                                                                                                                                                                                                                        type SearchBarProps = Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                        InputProps,
                                                                                                                                                                                                                                                                                                                                                                                                                        'onFocus' | 'onBlur' | 'onClear' | 'onCompositionStart' | 'onCompositionEnd'
                                                                                                                                                                                                                                                                                                                                                                                                                        > & {
                                                                                                                                                                                                                                                                                                                                                                                                                        value?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                        defaultValue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                        maxLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                        placeholder?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                        clearable?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                        onlyShowClearWhenFocus?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                        showCancelButton?: boolean | ((focus: boolean, value: string) => boolean);
                                                                                                                                                                                                                                                                                                                                                                                                                        cancelText?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                        icon?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                        clearOnCancel?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                        onSearch?: (val: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                        onChange?: (val: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                        onCancel?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                        } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                        | '--background'
                                                                                                                                                                                                                                                                                                                                                                                                                        | '--border-radius'
                                                                                                                                                                                                                                                                                                                                                                                                                        | '--placeholder-color'
                                                                                                                                                                                                                                                                                                                                                                                                                        | '--height'
                                                                                                                                                                                                                                                                                                                                                                                                                        | '--padding-left'
                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                          type SearchBarRef

                                                                                                                                                                                                                                                                                                                                                                                                                          type SearchBarRef = InputRef;

                                                                                                                                                                                                                                                                                                                                                                                                                            type SelectorOption

                                                                                                                                                                                                                                                                                                                                                                                                                            type SelectorOption<V> = {
                                                                                                                                                                                                                                                                                                                                                                                                                            label?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                            description?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                            value?: V;
                                                                                                                                                                                                                                                                                                                                                                                                                            disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                            } & BaseOptionType;

                                                                                                                                                                                                                                                                                                                                                                                                                              type SelectorProps

                                                                                                                                                                                                                                                                                                                                                                                                                              type SelectorProps<V> = {
                                                                                                                                                                                                                                                                                                                                                                                                                              options: SelectorOption<V>[];
                                                                                                                                                                                                                                                                                                                                                                                                                              columns?: GridProps['columns'];
                                                                                                                                                                                                                                                                                                                                                                                                                              multiple?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              defaultValue?: V[];
                                                                                                                                                                                                                                                                                                                                                                                                                              value?: V[];
                                                                                                                                                                                                                                                                                                                                                                                                                              onChange?: (
                                                                                                                                                                                                                                                                                                                                                                                                                              v: V[],
                                                                                                                                                                                                                                                                                                                                                                                                                              extend: {
                                                                                                                                                                                                                                                                                                                                                                                                                              items: SelectorOption<V>[];
                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                              showCheckMark?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              fieldNames?: FieldNamesType;
                                                                                                                                                                                                                                                                                                                                                                                                                              } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--color'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--checked-color'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--text-color'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--checked-text-color'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--border'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--checked-border'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--border-radius'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--padding'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--gap'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--gap-vertical'
                                                                                                                                                                                                                                                                                                                                                                                                                              | '--gap-horizontal'
                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                type SideBarItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                type SideBarItemProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                title?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                badge?: BadgeProps['content'];
                                                                                                                                                                                                                                                                                                                                                                                                                                } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                  type SideBarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                  type SideBarProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                  activeKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultActiveKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                  onChange?: (key: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                  children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                  } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                  '--width' | '--height' | '--item-border-radius' | '--background-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SkeletonProps

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SkeletonProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                    animated?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    } & NativeProps<'--width' | '--height' | '--border-radius'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      type SkeletonTitleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                      type SkeletonTitleProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                      animated?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                      } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                        type SliderProps

                                                                                                                                                                                                                                                                                                                                                                                                                                        type SliderProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                        min?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        max?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        value?: SliderValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultValue?: SliderValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                        step?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        marks?: SliderMarks;
                                                                                                                                                                                                                                                                                                                                                                                                                                        ticks?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        range?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        icon?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                        popover?: boolean | ((value: number) => ReactNode);
                                                                                                                                                                                                                                                                                                                                                                                                                                        residentPopover?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        onChange?: (value: SliderValue) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                        onAfterChange?: (value: SliderValue) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                        } & NativeProps<'--fill-color'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          type SpaceProps

                                                                                                                                                                                                                                                                                                                                                                                                                                          type SpaceProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                          direction?: 'horizontal' | 'vertical';
                                                                                                                                                                                                                                                                                                                                                                                                                                          align?: 'start' | 'end' | 'center' | 'baseline';
                                                                                                                                                                                                                                                                                                                                                                                                                                          justify?:
                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'start'
                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'end'
                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'center'
                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'between'
                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'around'
                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evenly'
                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'stretch';
                                                                                                                                                                                                                                                                                                                                                                                                                                          wrap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                          block?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                          onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                          children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                          } & NativeProps<'--gap' | '--gap-vertical' | '--gap-horizontal'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            type SpinLoadingProps

                                                                                                                                                                                                                                                                                                                                                                                                                                            type SpinLoadingProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                            color?: 'default' | 'primary' | 'white' | (string & {});
                                                                                                                                                                                                                                                                                                                                                                                                                                            } & NativeProps<'--color' | '--size'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              type StepperProps

                                                                                                                                                                                                                                                                                                                                                                                                                                              type StepperProps = NumberStepperProps | StringStepperProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                type StepperRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                type StepperRef = Pick<InputRef, 'blur' | 'focus' | 'nativeElement'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StepProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StepProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  title?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  description?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  icon?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  status?: 'wait' | 'process' | 'finish' | 'error';
                                                                                                                                                                                                                                                                                                                                                                                                                                                  } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StepsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StepsProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    current?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    direction?: Direction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--title-font-size'
                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--description-font-size'
                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--indicator-margin-right'
                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--icon-size'
                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SwipeActionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SwipeActionProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      rightActions?: Action[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                      leftActions?: Action[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAction?: (action: Action, e: React.MouseEvent) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      closeOnTouchOutside?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      closeOnAction?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      children: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      stopPropagation?: PropagationEvent[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                      onActionsReveal?: (side: SideType) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & NativeProps<'--background'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SwipeActionRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SwipeActionRef = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        close: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        show: (side?: SideType) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SwiperProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SwiperProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaultIndex?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          allowTouchMove?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoplay?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoplayInterval?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          loop?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          direction?: 'horizontal' | 'vertical';
                                                                                                                                                                                                                                                                                                                                                                                                                                                          onIndexChange?: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          indicatorProps?: Pick<PageIndicatorProps, 'color' | 'style' | 'className'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          indicator?: (total: number, current: number) => ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          slideSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          trackOffset?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          stuckAtBoundary?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          rubberband?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          stopPropagation?: PropagationEvent[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                          children?: ReactElement | ReactElement[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & NativeProps<'--height' | '--width' | '--border-radius' | '--track-padding'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SwiperRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SwiperRef = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            swipeTo: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            swipeNext: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            swipePrev: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SwitchProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SwitchProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              loading?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              checked?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              defaultChecked?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** @deprecated use `onChange` instead */
                                                                                                                                                                                                                                                                                                                                                                                                                                                              beforeChange?: (val: boolean) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              onChange?: (checked: boolean) => void | Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              checkedText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              uncheckedText?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              } & NativeProps<'--checked-color' | '--width' | '--height' | '--border-width'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TabBarItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TabBarItemProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                icon?: ReactNode | ((active: boolean) => ReactNode);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                title?: ReactNode | ((active: boolean) => ReactNode);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                badge?: BadgeProps['content'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TabBarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TabBarProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  activeKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultActiveKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onChange?: (key: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  safeArea?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TabProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TabProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    title: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forceRender?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    destroyOnClose?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TabsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TabsProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activeKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultActiveKey?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activeLineMode?: 'auto' | 'full' | 'fixed';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stretch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onChange?: (key: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      direction?: 'ltr' | 'rtl';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '--fixed-active-line-width'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '--active-line-height'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '--active-line-border-radius'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '--title-font-size'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '--content-padding'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '--active-title-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '--active-line-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TagProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TagProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        color?: 'default' | 'primary' | 'success' | 'warning' | 'danger' | (string & {});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fill?: 'solid' | 'outline';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        round?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onClick?: (e: React.MouseEvent<HTMLSpanElement, MouseEvent>) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        children?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        '--border-color' | '--background-color' | '--text-color' | '--border-radius'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TextAreaProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TextAreaProps = Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          React.DetailedHTMLProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          React.TextareaHTMLAttributes<HTMLTextAreaElement>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          HTMLTextAreaElement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'autoComplete'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'autoFocus'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'disabled'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'readOnly'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'onFocus'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'onBlur'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'onCompositionStart'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'onCompositionEnd'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'onClick'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onChange?: (val: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaultValue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          placeholder?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rows?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showCount?: boolean | ((length: number, maxLength?: number) => ReactNode);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoSize?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          minRows?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxRows?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | '--font-size'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | '--color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | '--placeholder-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | '--disabled-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | '--text-align'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | '--count-text-align'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TextAreaRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TextAreaRef = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            clear: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            focus: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            blur: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nativeElement: HTMLTextAreaElement | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ToastShowProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ToastShowProps = Omit<ToastProps, 'visible'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TreeSelectOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TreeSelectOption = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                label?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                children?: TreeSelectOption[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TreeSelectProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TreeSelectProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: TreeSelectOption[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultValue?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onChange?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extend: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: TreeSelectOption[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fieldNames?: FieldNamesType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } & NativeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VirtualInputProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VirtualInputProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onFocus?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onBlur?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keyboard?: ReactElement<NumberKeyboardProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clearable?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onClear?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } & Pick<InputProps, 'value' | 'onChange' | 'placeholder' | 'disabled'> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NativeProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--font-size'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--placeholder-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--disabled-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--text-align'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--caret-width'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | '--caret-color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VirtualInputRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VirtualInputRef = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      focus: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      blur: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WaterMarkProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WaterMarkProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gapX?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gapY?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        zIndex?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        width?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        height?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rotate?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        image?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imageWidth?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imageHeight?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        content?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fontColor?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fontStyle?: 'none' | 'normal' | 'italic' | 'oblique';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fontFamily?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fontWeight?: 'normal' | 'light' | 'weight' | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fontSize?: number | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fullPage?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } & NativeProps<'--z-index'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Package Files (132)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dependencies (17)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Peer Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/antd-mobile.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/antd-mobile)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/antd-mobile"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>