vant

  • Version 4.9.1
  • Published
  • 5.91 MB
  • 3 dependencies
  • MIT license

Install

npm i vant
yarn add vant
pnpm add vant

Overview

Mobile UI Components built on Vue

Index

Variables

Functions

Interfaces

Type Aliases

Namespaces

Variables

variable ActionBar

const ActionBar: any;

    variable ActionBarButton

    const ActionBarButton: any;

      variable actionBarButtonProps

      const actionBarButtonProps: {
      to: PropType<any>;
      url: StringConstructor;
      replace: BooleanConstructor;
      } & {
      type: PropType<ButtonType>;
      text: StringConstructor;
      icon: StringConstructor;
      color: StringConstructor;
      loading: BooleanConstructor;
      disabled: BooleanConstructor;
      };

        variable ActionBarIcon

        const ActionBarIcon: any;

          variable actionBarIconProps

          const actionBarIconProps: {
          to: PropType<any>;
          url: StringConstructor;
          replace: BooleanConstructor;
          } & {
          dot: BooleanConstructor;
          text: StringConstructor;
          icon: StringConstructor;
          color: StringConstructor;
          badge: (NumberConstructor | StringConstructor)[];
          iconClass: PropType<unknown>;
          badgeProps: PropType<
          ExtractPropTypes<{
          dot: BooleanConstructor;
          max: (StringConstructor | NumberConstructor)[];
          tag: {
          type: PropType<keyof HTMLElementTagNameMap>;
          default: keyof HTMLElementTagNameMap;
          };
          color: StringConstructor;
          offset: PropType<[Numeric, Numeric]>;
          content: (StringConstructor | NumberConstructor)[];
          showZero: { type: BooleanConstructor; default: true };
          position: { type: PropType<BadgePosition>; default: BadgePosition };
          }>
          >;
          iconPrefix: StringConstructor;
          };

            variable actionBarProps

            const actionBarProps: {
            placeholder: BooleanConstructor;
            safeAreaInsetBottom: { type: BooleanConstructor; default: true };
            };

              variable ActionSheet

              const ActionSheet: any;

                variable actionSheetProps

                const actionSheetProps: {
                show: BooleanConstructor;
                zIndex: (NumberConstructor | StringConstructor)[];
                overlay: { type: BooleanConstructor; default: true };
                duration: (NumberConstructor | StringConstructor)[];
                teleport: any;
                lockScroll: { type: BooleanConstructor; default: true };
                lazyRender: { type: BooleanConstructor; default: true };
                beforeClose: any;
                overlayStyle: any;
                overlayClass: any;
                transitionAppear: BooleanConstructor;
                closeOnClickOverlay: { type: BooleanConstructor; default: true };
                } & {
                title: StringConstructor;
                round: { type: BooleanConstructor; default: true };
                actions: {
                type: import('vue').PropType<ActionSheetAction[]>;
                default: () => never[];
                };
                closeIcon: { type: import('vue').PropType<string>; default: string };
                closeable: { type: BooleanConstructor; default: true };
                cancelText: StringConstructor;
                description: StringConstructor;
                closeOnPopstate: { type: BooleanConstructor; default: true };
                closeOnClickAction: BooleanConstructor;
                safeAreaInsetBottom: { type: BooleanConstructor; default: true };
                };

                  variable AddressEdit

                  const AddressEdit: any;

                    variable addressEditProps

                    const addressEditProps: {
                    areaList: PropType<AreaList>;
                    isSaving: BooleanConstructor;
                    isDeleting: BooleanConstructor;
                    validator: PropType<(key: string, value: string) => string | undefined>;
                    showArea: { type: BooleanConstructor; default: true };
                    showDetail: { type: BooleanConstructor; default: true };
                    showDelete: BooleanConstructor;
                    disableArea: BooleanConstructor;
                    searchResult: PropType<AddressEditSearchItem[]>;
                    telMaxlength: (NumberConstructor | StringConstructor)[];
                    showSetDefault: BooleanConstructor;
                    saveButtonText: StringConstructor;
                    areaPlaceholder: StringConstructor;
                    deleteButtonText: StringConstructor;
                    showSearchResult: BooleanConstructor;
                    detailRows: { type: (NumberConstructor | StringConstructor)[]; default: number };
                    detailMaxlength: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: number;
                    };
                    areaColumnsPlaceholder: { type: PropType<string[]>; default: () => never[] };
                    addressInfo: {
                    type: PropType<Partial<AddressEditInfo>>;
                    default: () => AddressEditInfo;
                    };
                    telValidator: {
                    type: PropType<(val: string) => boolean>;
                    default: typeof isMobile;
                    };
                    };

                      variable AddressList

                      const AddressList: any;

                        variable addressListProps

                        const addressListProps: {
                        list: { type: PropType<AddressListAddress[]>; default: () => never[] };
                        modelValue: PropType<string | number | (string | number)[]>;
                        switchable: { type: BooleanConstructor; default: true };
                        disabledText: StringConstructor;
                        disabledList: { type: PropType<AddressListAddress[]>; default: () => never[] };
                        showAddButton: { type: BooleanConstructor; default: true };
                        addButtonText: StringConstructor;
                        defaultTagText: StringConstructor;
                        rightIcon: { type: PropType<string>; default: string };
                        };

                          variable Area

                          const Area: any;

                            variable areaProps

                            const areaProps: Writeable<
                            Pick<
                            {
                            loading: BooleanConstructor;
                            readonly: BooleanConstructor;
                            allowHtml: BooleanConstructor;
                            optionHeight: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: number;
                            };
                            showToolbar: { type: BooleanConstructor; default: true };
                            swipeDuration: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: number;
                            };
                            visibleOptionNum: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: number;
                            };
                            } & {
                            title: StringConstructor;
                            cancelButtonText: StringConstructor;
                            confirmButtonText: StringConstructor;
                            },
                            | 'title'
                            | 'readonly'
                            | 'loading'
                            | 'optionHeight'
                            | 'swipeDuration'
                            | 'visibleOptionNum'
                            | 'cancelButtonText'
                            | 'confirmButtonText'
                            >
                            > & {
                            modelValue: StringConstructor;
                            columnsNum: { type: (NumberConstructor | StringConstructor)[]; default: number };
                            columnsPlaceholder: { type: PropType<string[]>; default: () => never[] };
                            areaList: { type: PropType<AreaList>; default: () => {} };
                            };

                              variable BackTop

                              const BackTop: any;

                                variable backTopProps

                                const backTopProps: {
                                right: (NumberConstructor | StringConstructor)[];
                                bottom: (NumberConstructor | StringConstructor)[];
                                zIndex: (NumberConstructor | StringConstructor)[];
                                target: PropType<any>;
                                offset: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                immediate: BooleanConstructor;
                                teleport: {
                                type: PropType<string | import('vue').RendererElement | null | undefined>;
                                default: string;
                                };
                                };

                                  variable Badge

                                  const Badge: any;

                                    variable badgeProps

                                    const badgeProps: {
                                    dot: BooleanConstructor;
                                    max: (NumberConstructor | StringConstructor)[];
                                    tag: {
                                    type: PropType<keyof HTMLElementTagNameMap>;
                                    default: keyof HTMLElementTagNameMap;
                                    };
                                    color: StringConstructor;
                                    offset: PropType<[Numeric, Numeric]>;
                                    content: (NumberConstructor | StringConstructor)[];
                                    showZero: { type: BooleanConstructor; default: true };
                                    position: { type: PropType<BadgePosition>; default: BadgePosition };
                                    };

                                      variable Barrage

                                      const Barrage: any;

                                        variable barrageProps

                                        const barrageProps: {
                                        top: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                        rows: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                        duration: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                        autoPlay: { type: BooleanConstructor; default: true };
                                        delay: { type: NumberConstructor; default: number };
                                        modelValue: {
                                        type: import('vue').PropType<BarrageItem[]>;
                                        default: () => never[];
                                        };
                                        };

                                          variable Button

                                          const Button: any;

                                            variable buttonProps

                                            const buttonProps: {
                                            to: PropType<any>;
                                            url: StringConstructor;
                                            replace: BooleanConstructor;
                                            } & {
                                            tag: {
                                            type: PropType<keyof HTMLElementTagNameMap>;
                                            default: keyof HTMLElementTagNameMap;
                                            };
                                            text: StringConstructor;
                                            icon: StringConstructor;
                                            type: { type: PropType<ButtonType>; default: ButtonType };
                                            size: { type: PropType<ButtonSize>; default: ButtonSize };
                                            color: StringConstructor;
                                            block: BooleanConstructor;
                                            plain: BooleanConstructor;
                                            round: BooleanConstructor;
                                            square: BooleanConstructor;
                                            loading: BooleanConstructor;
                                            hairline: BooleanConstructor;
                                            disabled: BooleanConstructor;
                                            iconPrefix: StringConstructor;
                                            nativeType: { type: PropType<ButtonNativeType>; default: ButtonNativeType };
                                            loadingSize: (NumberConstructor | StringConstructor)[];
                                            loadingText: StringConstructor;
                                            loadingType: PropType<LoadingType>;
                                            iconPosition: {
                                            type: PropType<ButtonIconPosition>;
                                            default: ButtonIconPosition;
                                            };
                                            };

                                              variable Calendar

                                              const Calendar: any;

                                                variable calendarProps

                                                const calendarProps: {
                                                show: BooleanConstructor;
                                                type: { type: PropType<CalendarType>; default: CalendarType };
                                                switchMode: { type: PropType<CalendarSwitchMode>; default: CalendarSwitchMode };
                                                title: StringConstructor;
                                                color: StringConstructor;
                                                round: { type: BooleanConstructor; default: true };
                                                readonly: BooleanConstructor;
                                                poppable: { type: BooleanConstructor; default: true };
                                                maxRange: { type: (NumberConstructor | StringConstructor)[]; default: null };
                                                position: { type: PropType<PopupPosition>; default: PopupPosition };
                                                teleport: PropType<any>;
                                                showMark: { type: BooleanConstructor; default: true };
                                                showTitle: { type: BooleanConstructor; default: true };
                                                formatter: PropType<(item: CalendarDayItem) => CalendarDayItem>;
                                                rowHeight: (NumberConstructor | StringConstructor)[];
                                                confirmText: StringConstructor;
                                                rangePrompt: StringConstructor;
                                                lazyRender: { type: BooleanConstructor; default: true };
                                                showConfirm: { type: BooleanConstructor; default: true };
                                                defaultDate: PropType<Date | Date[]>;
                                                allowSameDay: BooleanConstructor;
                                                showSubtitle: { type: BooleanConstructor; default: true };
                                                closeOnPopstate: { type: BooleanConstructor; default: true };
                                                showRangePrompt: { type: BooleanConstructor; default: true };
                                                confirmDisabledText: StringConstructor;
                                                closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                safeAreaInsetTop: BooleanConstructor;
                                                safeAreaInsetBottom: { type: BooleanConstructor; default: true };
                                                minDate: { type: DateConstructor; validator: (val: unknown) => val is Date };
                                                maxDate: { type: DateConstructor; validator: (val: unknown) => val is Date };
                                                firstDayOfWeek: {
                                                type: (NumberConstructor | StringConstructor)[];
                                                default: number;
                                                validator: (val: number) => boolean;
                                                };
                                                };

                                                  variable Card

                                                  const Card: any;

                                                    variable cardProps

                                                    const cardProps: {
                                                    tag: StringConstructor;
                                                    num: (NumberConstructor | StringConstructor)[];
                                                    desc: StringConstructor;
                                                    thumb: StringConstructor;
                                                    title: StringConstructor;
                                                    price: (NumberConstructor | StringConstructor)[];
                                                    centered: BooleanConstructor;
                                                    lazyLoad: BooleanConstructor;
                                                    currency: { type: import('vue').PropType<string>; default: string };
                                                    thumbLink: StringConstructor;
                                                    originPrice: (NumberConstructor | StringConstructor)[];
                                                    };

                                                      variable Cascader

                                                      const Cascader: any;

                                                        variable cascaderProps

                                                        const cascaderProps: {
                                                        title: StringConstructor;
                                                        options: { type: PropType<CascaderOption[]>; default: () => never[] };
                                                        closeable: { type: BooleanConstructor; default: true };
                                                        swipeable: { type: BooleanConstructor; default: true };
                                                        closeIcon: { type: PropType<string>; default: string };
                                                        showHeader: { type: BooleanConstructor; default: true };
                                                        modelValue: (NumberConstructor | StringConstructor)[];
                                                        fieldNames: PropType<CascaderFieldNames>;
                                                        placeholder: StringConstructor;
                                                        activeColor: StringConstructor;
                                                        };

                                                          variable Cell

                                                          const Cell: any;

                                                            variable CellGroup

                                                            const CellGroup: any;

                                                              variable cellGroupProps

                                                              const cellGroupProps: {
                                                              title: StringConstructor;
                                                              inset: BooleanConstructor;
                                                              border: { type: BooleanConstructor; default: true };
                                                              };

                                                                variable cellProps

                                                                const cellProps: {
                                                                tag: {
                                                                type: PropType<keyof HTMLElementTagNameMap>;
                                                                default: keyof HTMLElementTagNameMap;
                                                                };
                                                                icon: StringConstructor;
                                                                size: PropType<CellSize>;
                                                                title: (NumberConstructor | StringConstructor)[];
                                                                value: (NumberConstructor | StringConstructor)[];
                                                                label: (NumberConstructor | StringConstructor)[];
                                                                center: BooleanConstructor;
                                                                isLink: BooleanConstructor;
                                                                border: { type: BooleanConstructor; default: true };
                                                                iconPrefix: StringConstructor;
                                                                valueClass: PropType<unknown>;
                                                                labelClass: PropType<unknown>;
                                                                titleClass: PropType<unknown>;
                                                                titleStyle: PropType<any>;
                                                                arrowDirection: PropType<CellArrowDirection>;
                                                                required: { type: PropType<boolean | 'auto'>; default: null };
                                                                clickable: { type: PropType<boolean | null>; default: null };
                                                                } & { to: PropType<any>; url: StringConstructor; replace: BooleanConstructor };

                                                                  variable Checkbox

                                                                  const Checkbox: any;

                                                                    variable CheckboxGroup

                                                                    const CheckboxGroup: any;

                                                                      variable checkboxGroupProps

                                                                      const checkboxGroupProps: {
                                                                      max: (NumberConstructor | StringConstructor)[];
                                                                      shape: { type: PropType<CheckerShape>; default: CheckerShape };
                                                                      disabled: BooleanConstructor;
                                                                      iconSize: (NumberConstructor | StringConstructor)[];
                                                                      direction: PropType<CheckerDirection>;
                                                                      modelValue: { type: PropType<unknown[]>; default: () => never[] };
                                                                      checkedColor: StringConstructor;
                                                                      };

                                                                        variable checkboxProps

                                                                        const checkboxProps: {
                                                                        name: PropType<unknown>;
                                                                        disabled: BooleanConstructor;
                                                                        iconSize: (NumberConstructor | StringConstructor)[];
                                                                        modelValue: PropType<unknown>;
                                                                        checkedColor: StringConstructor;
                                                                        labelPosition: PropType<CheckerLabelPosition>;
                                                                        labelDisabled: BooleanConstructor;
                                                                        } & {
                                                                        shape: PropType<CheckerShape>;
                                                                        bindGroup: { type: BooleanConstructor; default: true };
                                                                        indeterminate: { type: PropType<boolean | null>; default: null };
                                                                        };

                                                                          variable Circle

                                                                          const Circle: any;

                                                                            variable circleProps

                                                                            const circleProps: {
                                                                            text: StringConstructor;
                                                                            size: (NumberConstructor | StringConstructor)[];
                                                                            fill: { type: PropType<string>; default: string };
                                                                            rate: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                            speed: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                            color: PropType<string | Record<string, string>>;
                                                                            clockwise: { type: BooleanConstructor; default: true };
                                                                            layerColor: StringConstructor;
                                                                            currentRate: { type: NumberConstructor; default: number };
                                                                            strokeWidth: {
                                                                            type: (NumberConstructor | StringConstructor)[];
                                                                            default: number;
                                                                            };
                                                                            strokeLinecap: PropType<CanvasLineCap>;
                                                                            startPosition: {
                                                                            type: PropType<CircleStartPosition>;
                                                                            default: CircleStartPosition;
                                                                            };
                                                                            };

                                                                              variable Col

                                                                              const Col: any;

                                                                                variable Collapse

                                                                                const Collapse: any;

                                                                                  variable CollapseItem

                                                                                  const CollapseItem: any;

                                                                                    variable collapseItemProps

                                                                                    const collapseItemProps: {
                                                                                    tag: {
                                                                                    type: import('vue').PropType<keyof HTMLElementTagNameMap>;
                                                                                    default: keyof HTMLElementTagNameMap;
                                                                                    };
                                                                                    icon: StringConstructor;
                                                                                    size: any;
                                                                                    title: (NumberConstructor | StringConstructor)[];
                                                                                    value: (NumberConstructor | StringConstructor)[];
                                                                                    label: (NumberConstructor | StringConstructor)[];
                                                                                    center: BooleanConstructor;
                                                                                    isLink: BooleanConstructor;
                                                                                    border: { type: BooleanConstructor; default: true };
                                                                                    iconPrefix: StringConstructor;
                                                                                    valueClass: any;
                                                                                    labelClass: any;
                                                                                    titleClass: any;
                                                                                    titleStyle: any;
                                                                                    arrowDirection: any;
                                                                                    required: { type: import('vue').PropType<boolean | 'auto'>; default: null };
                                                                                    clickable: { type: import('vue').PropType<boolean | null>; default: null };
                                                                                    } & {
                                                                                    name: (NumberConstructor | StringConstructor)[];
                                                                                    isLink: { type: BooleanConstructor; default: true };
                                                                                    disabled: BooleanConstructor;
                                                                                    readonly: BooleanConstructor;
                                                                                    lazyRender: { type: BooleanConstructor; default: true };
                                                                                    };

                                                                                      variable collapseProps

                                                                                      const collapseProps: {
                                                                                      border: { type: BooleanConstructor; default: true };
                                                                                      accordion: BooleanConstructor;
                                                                                      modelValue: { type: PropType<Numeric | Numeric[]>; default: string };
                                                                                      };

                                                                                        variable colProps

                                                                                        const colProps: {
                                                                                        tag: {
                                                                                        type: import('vue').PropType<keyof HTMLElementTagNameMap>;
                                                                                        default: keyof HTMLElementTagNameMap;
                                                                                        };
                                                                                        span: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                        offset: (NumberConstructor | StringConstructor)[];
                                                                                        };

                                                                                          variable ConfigProvider

                                                                                          const ConfigProvider: any;

                                                                                            variable configProviderProps

                                                                                            const configProviderProps: {
                                                                                            tag: {
                                                                                            type: PropType<keyof HTMLElementTagNameMap>;
                                                                                            default: keyof HTMLElementTagNameMap;
                                                                                            };
                                                                                            theme: { type: PropType<ConfigProviderTheme>; default: ConfigProviderTheme };
                                                                                            zIndex: NumberConstructor;
                                                                                            themeVars: PropType<Record<string, Numeric>>;
                                                                                            themeVarsDark: PropType<Record<string, Numeric>>;
                                                                                            themeVarsLight: PropType<Record<string, Numeric>>;
                                                                                            themeVarsScope: {
                                                                                            type: PropType<ConfigProviderThemeVarsScope>;
                                                                                            default: ConfigProviderThemeVarsScope;
                                                                                            };
                                                                                            iconPrefix: StringConstructor;
                                                                                            };

                                                                                              variable ContactCard

                                                                                              const ContactCard: any;

                                                                                                variable contactCardProps

                                                                                                const contactCardProps: {
                                                                                                tel: StringConstructor;
                                                                                                name: StringConstructor;
                                                                                                type: {
                                                                                                type: import('vue').PropType<ContactCardType>;
                                                                                                default: ContactCardType;
                                                                                                };
                                                                                                addText: StringConstructor;
                                                                                                editable: { type: BooleanConstructor; default: true };
                                                                                                };

                                                                                                  variable ContactEdit

                                                                                                  const ContactEdit: any;

                                                                                                    variable contactEditProps

                                                                                                    const contactEditProps: {
                                                                                                    isEdit: BooleanConstructor;
                                                                                                    isSaving: BooleanConstructor;
                                                                                                    isDeleting: BooleanConstructor;
                                                                                                    showSetDefault: BooleanConstructor;
                                                                                                    setDefaultLabel: StringConstructor;
                                                                                                    contactInfo: { type: PropType<ContactEditInfo>; default: () => ContactEditInfo };
                                                                                                    telValidator: {
                                                                                                    type: PropType<(val: string) => boolean>;
                                                                                                    default: typeof isMobile;
                                                                                                    };
                                                                                                    };

                                                                                                      variable ContactList

                                                                                                      const ContactList: any;

                                                                                                        variable contactListProps

                                                                                                        const contactListProps: {
                                                                                                        list: PropType<ContactListItem[]>;
                                                                                                        addText: StringConstructor;
                                                                                                        modelValue: PropType<unknown>;
                                                                                                        defaultTagText: StringConstructor;
                                                                                                        };

                                                                                                          variable CountDown

                                                                                                          const CountDown: any;

                                                                                                            variable countDownProps

                                                                                                            const countDownProps: {
                                                                                                            time: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                            format: { type: import('vue').PropType<string>; default: string };
                                                                                                            autoStart: { type: BooleanConstructor; default: true };
                                                                                                            millisecond: BooleanConstructor;
                                                                                                            };

                                                                                                              variable Coupon

                                                                                                              const Coupon: any;

                                                                                                                variable CouponCell

                                                                                                                const CouponCell: any;

                                                                                                                  variable couponCellProps

                                                                                                                  const couponCellProps: {
                                                                                                                  title: StringConstructor;
                                                                                                                  border: { type: BooleanConstructor; default: true };
                                                                                                                  editable: { type: BooleanConstructor; default: true };
                                                                                                                  coupons: { type: PropType<CouponInfo[]>; default: () => never[] };
                                                                                                                  currency: { type: PropType<string>; default: string };
                                                                                                                  chosenCoupon: { type: PropType<number | number[]>; default: number };
                                                                                                                  };

                                                                                                                    variable CouponList

                                                                                                                    const CouponList: any;

                                                                                                                      variable couponListProps

                                                                                                                      const couponListProps: {
                                                                                                                      code: { type: PropType<string>; default: string };
                                                                                                                      coupons: { type: PropType<CouponInfo[]>; default: () => never[] };
                                                                                                                      currency: { type: PropType<string>; default: string };
                                                                                                                      showCount: { type: BooleanConstructor; default: true };
                                                                                                                      emptyImage: StringConstructor;
                                                                                                                      enabledTitle: StringConstructor;
                                                                                                                      disabledTitle: StringConstructor;
                                                                                                                      disabledCoupons: { type: PropType<CouponInfo[]>; default: () => never[] };
                                                                                                                      showExchangeBar: { type: BooleanConstructor; default: true };
                                                                                                                      showCloseButton: { type: BooleanConstructor; default: true };
                                                                                                                      closeButtonText: StringConstructor;
                                                                                                                      inputPlaceholder: StringConstructor;
                                                                                                                      exchangeMinLength: { type: NumberConstructor; default: number };
                                                                                                                      exchangeButtonText: StringConstructor;
                                                                                                                      displayedCouponIndex: { type: NumberConstructor; default: number };
                                                                                                                      exchangeButtonLoading: BooleanConstructor;
                                                                                                                      exchangeButtonDisabled: BooleanConstructor;
                                                                                                                      chosenCoupon: { type: PropType<number | number[]>; default: number };
                                                                                                                      };

                                                                                                                        variable DatePicker

                                                                                                                        const DatePicker: any;

                                                                                                                          variable datePickerProps

                                                                                                                          const datePickerProps: {
                                                                                                                          loading: BooleanConstructor;
                                                                                                                          readonly: BooleanConstructor;
                                                                                                                          allowHtml: BooleanConstructor;
                                                                                                                          optionHeight: {
                                                                                                                          type: (NumberConstructor | StringConstructor)[];
                                                                                                                          default: number;
                                                                                                                          };
                                                                                                                          showToolbar: { type: BooleanConstructor; default: true };
                                                                                                                          swipeDuration: {
                                                                                                                          type: (NumberConstructor | StringConstructor)[];
                                                                                                                          default: number;
                                                                                                                          };
                                                                                                                          visibleOptionNum: {
                                                                                                                          type: (NumberConstructor | StringConstructor)[];
                                                                                                                          default: number;
                                                                                                                          };
                                                                                                                          } & {
                                                                                                                          title: StringConstructor;
                                                                                                                          cancelButtonText: StringConstructor;
                                                                                                                          confirmButtonText: StringConstructor;
                                                                                                                          } & {
                                                                                                                          modelValue: { type: PropType<string[]>; default: () => never[] };
                                                                                                                          filter: PropType<
                                                                                                                          (
                                                                                                                          columnType: string,
                                                                                                                          options: import('../picker').PickerOption[],
                                                                                                                          values?: string[] | undefined
                                                                                                                          ) => import('../picker').PickerOption[]
                                                                                                                          >;
                                                                                                                          formatter: {
                                                                                                                          type: PropType<
                                                                                                                          (
                                                                                                                          type: string,
                                                                                                                          option: import('../picker').PickerOption
                                                                                                                          ) => import('../picker').PickerOption
                                                                                                                          >;
                                                                                                                          default: (
                                                                                                                          type: string,
                                                                                                                          option: import('../picker').PickerOption
                                                                                                                          ) => import('../picker').PickerOption;
                                                                                                                          };
                                                                                                                          } & {
                                                                                                                          columnsType: { type: PropType<DatePickerColumnType[]>; default: () => string[] };
                                                                                                                          minDate: {
                                                                                                                          type: DateConstructor;
                                                                                                                          default: () => Date;
                                                                                                                          validator: (val: unknown) => val is Date;
                                                                                                                          };
                                                                                                                          maxDate: {
                                                                                                                          type: DateConstructor;
                                                                                                                          default: () => Date;
                                                                                                                          validator: (val: unknown) => val is Date;
                                                                                                                          };
                                                                                                                          };

                                                                                                                            variable DEFAULT_ROW_WIDTH

                                                                                                                            const DEFAULT_ROW_WIDTH: string;

                                                                                                                              variable Dialog

                                                                                                                              const Dialog: any;

                                                                                                                                variable dialogProps

                                                                                                                                const dialogProps: {
                                                                                                                                show: BooleanConstructor;
                                                                                                                                zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                overlay: { type: BooleanConstructor; default: true };
                                                                                                                                duration: (NumberConstructor | StringConstructor)[];
                                                                                                                                teleport: PropType<any>;
                                                                                                                                lockScroll: { type: BooleanConstructor; default: true };
                                                                                                                                lazyRender: { type: BooleanConstructor; default: true };
                                                                                                                                beforeClose: PropType<Interceptor>;
                                                                                                                                overlayStyle: PropType<any>;
                                                                                                                                overlayClass: PropType<unknown>;
                                                                                                                                transitionAppear: BooleanConstructor;
                                                                                                                                closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                                                                                                } & {
                                                                                                                                title: StringConstructor;
                                                                                                                                theme: PropType<DialogTheme>;
                                                                                                                                width: (NumberConstructor | StringConstructor)[];
                                                                                                                                message: PropType<DialogMessage>;
                                                                                                                                callback: PropType<(action?: DialogAction) => void>;
                                                                                                                                allowHtml: BooleanConstructor;
                                                                                                                                className: PropType<unknown>;
                                                                                                                                transition: { type: PropType<string>; default: string };
                                                                                                                                messageAlign: PropType<DialogMessageAlign>;
                                                                                                                                closeOnPopstate: { type: BooleanConstructor; default: true };
                                                                                                                                showCancelButton: BooleanConstructor;
                                                                                                                                cancelButtonText: StringConstructor;
                                                                                                                                cancelButtonColor: StringConstructor;
                                                                                                                                cancelButtonDisabled: BooleanConstructor;
                                                                                                                                confirmButtonText: StringConstructor;
                                                                                                                                confirmButtonColor: StringConstructor;
                                                                                                                                confirmButtonDisabled: BooleanConstructor;
                                                                                                                                showConfirmButton: { type: BooleanConstructor; default: true };
                                                                                                                                closeOnClickOverlay: BooleanConstructor;
                                                                                                                                };

                                                                                                                                  variable Divider

                                                                                                                                  const Divider: any;

                                                                                                                                    variable dividerProps

                                                                                                                                    const dividerProps: {
                                                                                                                                    dashed: BooleanConstructor;
                                                                                                                                    hairline: { type: BooleanConstructor; default: true };
                                                                                                                                    vertical: BooleanConstructor;
                                                                                                                                    contentPosition: {
                                                                                                                                    type: import('vue').PropType<DividerContentPosition>;
                                                                                                                                    default: DividerContentPosition;
                                                                                                                                    };
                                                                                                                                    };
                                                                                                                                      const DropdownItem: any;
                                                                                                                                        const dropdownItemProps: {
                                                                                                                                        title: StringConstructor;
                                                                                                                                        options: { type: PropType<DropdownItemOption[]>; default: () => never[] };
                                                                                                                                        disabled: BooleanConstructor;
                                                                                                                                        teleport: PropType<any>;
                                                                                                                                        lazyRender: { type: BooleanConstructor; default: true };
                                                                                                                                        modelValue: PropType<unknown>;
                                                                                                                                        titleClass: PropType<unknown>;
                                                                                                                                        };
                                                                                                                                          const DropdownMenu: any;
                                                                                                                                            const dropdownMenuProps: {
                                                                                                                                            overlay: { type: BooleanConstructor; default: true };
                                                                                                                                            zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                            duration: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                            direction: {
                                                                                                                                            type: import('vue').PropType<DropdownMenuDirection>;
                                                                                                                                            default: DropdownMenuDirection;
                                                                                                                                            };
                                                                                                                                            activeColor: StringConstructor;
                                                                                                                                            autoLocate: BooleanConstructor;
                                                                                                                                            closeOnClickOutside: { type: BooleanConstructor; default: true };
                                                                                                                                            closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                                                                                                            swipeThreshold: (NumberConstructor | StringConstructor)[];
                                                                                                                                            };

                                                                                                                                              variable Empty

                                                                                                                                              const Empty: any;

                                                                                                                                                variable emptyProps

                                                                                                                                                const emptyProps: {
                                                                                                                                                image: { type: PropType<string>; default: string };
                                                                                                                                                imageSize: PropType<Numeric | [Numeric, Numeric]>;
                                                                                                                                                description: StringConstructor;
                                                                                                                                                };

                                                                                                                                                  variable Field

                                                                                                                                                  const Field: any;

                                                                                                                                                    variable fieldProps

                                                                                                                                                    const fieldProps: {
                                                                                                                                                    tag: {
                                                                                                                                                    type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                    default: keyof HTMLElementTagNameMap;
                                                                                                                                                    };
                                                                                                                                                    icon: StringConstructor;
                                                                                                                                                    size: PropType<CellSize>;
                                                                                                                                                    title: (NumberConstructor | StringConstructor)[];
                                                                                                                                                    value: (NumberConstructor | StringConstructor)[];
                                                                                                                                                    label: (NumberConstructor | StringConstructor)[];
                                                                                                                                                    center: BooleanConstructor;
                                                                                                                                                    isLink: BooleanConstructor;
                                                                                                                                                    border: { type: BooleanConstructor; default: true };
                                                                                                                                                    iconPrefix: StringConstructor;
                                                                                                                                                    valueClass: PropType<unknown>;
                                                                                                                                                    labelClass: PropType<unknown>;
                                                                                                                                                    titleClass: PropType<unknown>;
                                                                                                                                                    titleStyle: PropType<any>;
                                                                                                                                                    arrowDirection: PropType<CellArrowDirection>;
                                                                                                                                                    required: { type: PropType<boolean | 'auto'>; default: null };
                                                                                                                                                    clickable: { type: PropType<boolean | null>; default: null };
                                                                                                                                                    } & {
                                                                                                                                                    id: StringConstructor;
                                                                                                                                                    name: StringConstructor;
                                                                                                                                                    leftIcon: StringConstructor;
                                                                                                                                                    rightIcon: StringConstructor;
                                                                                                                                                    autofocus: BooleanConstructor;
                                                                                                                                                    clearable: BooleanConstructor;
                                                                                                                                                    maxlength: (NumberConstructor | StringConstructor)[];
                                                                                                                                                    formatter: PropType<(value: string) => string>;
                                                                                                                                                    clearIcon: { type: PropType<string>; default: string };
                                                                                                                                                    modelValue: { type: (NumberConstructor | StringConstructor)[]; default: string };
                                                                                                                                                    inputAlign: PropType<FieldTextAlign>;
                                                                                                                                                    placeholder: StringConstructor;
                                                                                                                                                    autocomplete: StringConstructor;
                                                                                                                                                    autocapitalize: StringConstructor;
                                                                                                                                                    autocorrect: StringConstructor;
                                                                                                                                                    errorMessage: StringConstructor;
                                                                                                                                                    enterkeyhint: StringConstructor;
                                                                                                                                                    clearTrigger: { type: PropType<FieldClearTrigger>; default: FieldClearTrigger };
                                                                                                                                                    formatTrigger: {
                                                                                                                                                    type: PropType<FieldFormatTrigger>;
                                                                                                                                                    default: FieldFormatTrigger;
                                                                                                                                                    };
                                                                                                                                                    spellcheck: { type: BooleanConstructor; default: null };
                                                                                                                                                    error: { type: BooleanConstructor; default: null };
                                                                                                                                                    disabled: { type: BooleanConstructor; default: null };
                                                                                                                                                    readonly: { type: BooleanConstructor; default: null };
                                                                                                                                                    } & {
                                                                                                                                                    rows: (NumberConstructor | StringConstructor)[];
                                                                                                                                                    type: { type: PropType<FieldType>; default: FieldType };
                                                                                                                                                    rules: PropType<FieldRule[]>;
                                                                                                                                                    autosize: PropType<boolean | FieldAutosizeConfig>;
                                                                                                                                                    labelWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                    labelClass: PropType<unknown>;
                                                                                                                                                    labelAlign: PropType<FieldTextAlign>;
                                                                                                                                                    showWordLimit: BooleanConstructor;
                                                                                                                                                    errorMessageAlign: PropType<FieldTextAlign>;
                                                                                                                                                    colon: { type: BooleanConstructor; default: null };
                                                                                                                                                    };

                                                                                                                                                      variable FloatingBubble

                                                                                                                                                      const FloatingBubble: any;

                                                                                                                                                        variable floatingBubbleProps

                                                                                                                                                        const floatingBubbleProps: {
                                                                                                                                                        gap: { type: NumberConstructor; default: number };
                                                                                                                                                        icon: StringConstructor;
                                                                                                                                                        axis: { type: PropType<FloatingBubbleAxis>; default: FloatingBubbleAxis };
                                                                                                                                                        magnetic: PropType<FloatingBubbleMagnetic>;
                                                                                                                                                        offset: {
                                                                                                                                                        type: PropType<FloatingBubbleOffset>;
                                                                                                                                                        default: () => { x: number; y: number };
                                                                                                                                                        };
                                                                                                                                                        teleport: {
                                                                                                                                                        type: PropType<string | import('vue').RendererElement | null | undefined>;
                                                                                                                                                        default: string;
                                                                                                                                                        };
                                                                                                                                                        };

                                                                                                                                                          variable FloatingPanel

                                                                                                                                                          const FloatingPanel: any;

                                                                                                                                                            variable floatingPanelProps

                                                                                                                                                            const floatingPanelProps: {
                                                                                                                                                            height: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                            anchors: { type: import('vue').PropType<number[]>; default: () => never[] };
                                                                                                                                                            duration: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                            contentDraggable: { type: BooleanConstructor; default: true };
                                                                                                                                                            lockScroll: BooleanConstructor;
                                                                                                                                                            safeAreaInsetBottom: { type: BooleanConstructor; default: true };
                                                                                                                                                            };

                                                                                                                                                              variable Form

                                                                                                                                                              const Form: any;

                                                                                                                                                                variable formProps

                                                                                                                                                                const formProps: {
                                                                                                                                                                colon: BooleanConstructor;
                                                                                                                                                                disabled: BooleanConstructor;
                                                                                                                                                                readonly: BooleanConstructor;
                                                                                                                                                                required: PropType<boolean | 'auto'>;
                                                                                                                                                                showError: BooleanConstructor;
                                                                                                                                                                labelWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                labelAlign: PropType<FieldTextAlign>;
                                                                                                                                                                inputAlign: PropType<FieldTextAlign>;
                                                                                                                                                                scrollToError: BooleanConstructor;
                                                                                                                                                                validateFirst: BooleanConstructor;
                                                                                                                                                                submitOnEnter: { type: BooleanConstructor; default: true };
                                                                                                                                                                showErrorMessage: { type: BooleanConstructor; default: true };
                                                                                                                                                                errorMessageAlign: PropType<FieldTextAlign>;
                                                                                                                                                                validateTrigger: {
                                                                                                                                                                type: PropType<FieldValidateTrigger | FieldValidateTrigger[]>;
                                                                                                                                                                default: string;
                                                                                                                                                                };
                                                                                                                                                                };

                                                                                                                                                                  variable Grid

                                                                                                                                                                  const Grid: any;

                                                                                                                                                                    variable GridItem

                                                                                                                                                                    const GridItem: any;

                                                                                                                                                                      variable gridItemProps

                                                                                                                                                                      const gridItemProps: {
                                                                                                                                                                      to: PropType<any>;
                                                                                                                                                                      url: StringConstructor;
                                                                                                                                                                      replace: BooleanConstructor;
                                                                                                                                                                      } & {
                                                                                                                                                                      dot: BooleanConstructor;
                                                                                                                                                                      text: StringConstructor;
                                                                                                                                                                      icon: StringConstructor;
                                                                                                                                                                      badge: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                      iconColor: StringConstructor;
                                                                                                                                                                      iconPrefix: StringConstructor;
                                                                                                                                                                      badgeProps: PropType<
                                                                                                                                                                      ExtractPropTypes<{
                                                                                                                                                                      dot: BooleanConstructor;
                                                                                                                                                                      max: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                      tag: {
                                                                                                                                                                      type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                      default: keyof HTMLElementTagNameMap;
                                                                                                                                                                      };
                                                                                                                                                                      color: StringConstructor;
                                                                                                                                                                      offset: PropType<[Numeric, Numeric]>;
                                                                                                                                                                      content: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                      showZero: { type: BooleanConstructor; default: true };
                                                                                                                                                                      position: { type: PropType<BadgePosition>; default: BadgePosition };
                                                                                                                                                                      }>
                                                                                                                                                                      >;
                                                                                                                                                                      };

                                                                                                                                                                        variable gridProps

                                                                                                                                                                        const gridProps: {
                                                                                                                                                                        square: BooleanConstructor;
                                                                                                                                                                        center: { type: BooleanConstructor; default: true };
                                                                                                                                                                        border: { type: BooleanConstructor; default: true };
                                                                                                                                                                        gutter: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                        reverse: BooleanConstructor;
                                                                                                                                                                        iconSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                        direction: PropType<GridDirection>;
                                                                                                                                                                        clickable: BooleanConstructor;
                                                                                                                                                                        columnNum: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                        };

                                                                                                                                                                          variable Highlight

                                                                                                                                                                          const Highlight: any;

                                                                                                                                                                            variable highlightProps

                                                                                                                                                                            const highlightProps: {
                                                                                                                                                                            autoEscape: { type: BooleanConstructor; default: true };
                                                                                                                                                                            caseSensitive: BooleanConstructor;
                                                                                                                                                                            highlightClass: StringConstructor;
                                                                                                                                                                            highlightTag: {
                                                                                                                                                                            type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                            default: keyof HTMLElementTagNameMap;
                                                                                                                                                                            };
                                                                                                                                                                            keywords: { type: PropType<string | string[]>; required: true };
                                                                                                                                                                            sourceString: { type: PropType<string>; default: string };
                                                                                                                                                                            tag: {
                                                                                                                                                                            type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                            default: keyof HTMLElementTagNameMap;
                                                                                                                                                                            };
                                                                                                                                                                            unhighlightClass: StringConstructor;
                                                                                                                                                                            unhighlightTag: {
                                                                                                                                                                            type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                            default: keyof HTMLElementTagNameMap;
                                                                                                                                                                            };
                                                                                                                                                                            };

                                                                                                                                                                              variable Icon

                                                                                                                                                                              const Icon: any;

                                                                                                                                                                                variable iconProps

                                                                                                                                                                                const iconProps: {
                                                                                                                                                                                dot: BooleanConstructor;
                                                                                                                                                                                tag: {
                                                                                                                                                                                type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                                default: keyof HTMLElementTagNameMap;
                                                                                                                                                                                };
                                                                                                                                                                                name: StringConstructor;
                                                                                                                                                                                size: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                badge: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                color: StringConstructor;
                                                                                                                                                                                badgeProps: PropType<
                                                                                                                                                                                ExtractPropTypes<{
                                                                                                                                                                                dot: BooleanConstructor;
                                                                                                                                                                                max: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                                tag: {
                                                                                                                                                                                type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                                default: keyof HTMLElementTagNameMap;
                                                                                                                                                                                };
                                                                                                                                                                                color: StringConstructor;
                                                                                                                                                                                offset: PropType<[Numeric, Numeric]>;
                                                                                                                                                                                content: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                                showZero: { type: BooleanConstructor; default: true };
                                                                                                                                                                                position: { type: PropType<BadgePosition>; default: BadgePosition };
                                                                                                                                                                                }>
                                                                                                                                                                                >;
                                                                                                                                                                                classPrefix: StringConstructor;
                                                                                                                                                                                };

                                                                                                                                                                                  variable Image

                                                                                                                                                                                  const Image: any;

                                                                                                                                                                                    variable ImagePreview

                                                                                                                                                                                    const ImagePreview: any;

                                                                                                                                                                                      variable imagePreviewProps

                                                                                                                                                                                      const imagePreviewProps: {
                                                                                                                                                                                      show: BooleanConstructor;
                                                                                                                                                                                      loop: { type: BooleanConstructor; default: true };
                                                                                                                                                                                      images: { type: PropType<string[]>; default: () => never[] };
                                                                                                                                                                                      minZoom: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                      maxZoom: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                      overlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                      vertical: BooleanConstructor;
                                                                                                                                                                                      closeable: BooleanConstructor;
                                                                                                                                                                                      showIndex: { type: BooleanConstructor; default: true };
                                                                                                                                                                                      className: PropType<unknown>;
                                                                                                                                                                                      closeIcon: { type: PropType<string>; default: string };
                                                                                                                                                                                      transition: StringConstructor;
                                                                                                                                                                                      beforeClose: PropType<Interceptor>;
                                                                                                                                                                                      doubleScale: { type: BooleanConstructor; default: true };
                                                                                                                                                                                      overlayClass: PropType<unknown>;
                                                                                                                                                                                      overlayStyle: PropType<CSSProperties>;
                                                                                                                                                                                      swipeDuration: {
                                                                                                                                                                                      type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                      default: number;
                                                                                                                                                                                      };
                                                                                                                                                                                      startPosition: {
                                                                                                                                                                                      type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                      default: number;
                                                                                                                                                                                      };
                                                                                                                                                                                      showIndicators: BooleanConstructor;
                                                                                                                                                                                      closeOnPopstate: { type: BooleanConstructor; default: true };
                                                                                                                                                                                      closeOnClickImage: { type: BooleanConstructor; default: true };
                                                                                                                                                                                      closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                      closeIconPosition: {
                                                                                                                                                                                      type: PropType<PopupCloseIconPosition>;
                                                                                                                                                                                      default: PopupCloseIconPosition;
                                                                                                                                                                                      };
                                                                                                                                                                                      teleport: PropType<any>;
                                                                                                                                                                                      };

                                                                                                                                                                                        variable imageProps

                                                                                                                                                                                        const imageProps: {
                                                                                                                                                                                        src: StringConstructor;
                                                                                                                                                                                        alt: StringConstructor;
                                                                                                                                                                                        fit: PropType<any>;
                                                                                                                                                                                        position: PropType<any>;
                                                                                                                                                                                        round: BooleanConstructor;
                                                                                                                                                                                        block: BooleanConstructor;
                                                                                                                                                                                        width: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                        height: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                        radius: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                        lazyLoad: BooleanConstructor;
                                                                                                                                                                                        iconSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                        showError: { type: BooleanConstructor; default: true };
                                                                                                                                                                                        errorIcon: { type: PropType<string>; default: string };
                                                                                                                                                                                        iconPrefix: StringConstructor;
                                                                                                                                                                                        showLoading: { type: BooleanConstructor; default: true };
                                                                                                                                                                                        loadingIcon: { type: PropType<string>; default: string };
                                                                                                                                                                                        crossorigin: PropType<'' | 'anonymous' | 'use-credentials'>;
                                                                                                                                                                                        referrerpolicy: PropType<
                                                                                                                                                                                        | ''
                                                                                                                                                                                        | 'no-referrer'
                                                                                                                                                                                        | 'no-referrer-when-downgrade'
                                                                                                                                                                                        | 'origin'
                                                                                                                                                                                        | 'origin-when-cross-origin'
                                                                                                                                                                                        | 'same-origin'
                                                                                                                                                                                        | 'strict-origin'
                                                                                                                                                                                        | 'strict-origin-when-cross-origin'
                                                                                                                                                                                        | 'unsafe-url'
                                                                                                                                                                                        >;
                                                                                                                                                                                        };

                                                                                                                                                                                          variable IndexAnchor

                                                                                                                                                                                          const IndexAnchor: any;

                                                                                                                                                                                            variable indexAnchorProps

                                                                                                                                                                                            const indexAnchorProps: { index: (NumberConstructor | StringConstructor)[] };

                                                                                                                                                                                              variable IndexBar

                                                                                                                                                                                              const IndexBar: any;

                                                                                                                                                                                                variable indexBarProps

                                                                                                                                                                                                const indexBarProps: {
                                                                                                                                                                                                sticky: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                teleport: PropType<any>;
                                                                                                                                                                                                highlightColor: StringConstructor;
                                                                                                                                                                                                stickyOffsetTop: { type: NumberConstructor; default: number };
                                                                                                                                                                                                indexList: { type: PropType<Numeric[]>; default: typeof genAlphabet };
                                                                                                                                                                                                };

                                                                                                                                                                                                  variable Lazyload

                                                                                                                                                                                                  const Lazyload: { install(app: App, options?: LazyloadOptions): void };

                                                                                                                                                                                                    variable List

                                                                                                                                                                                                    const List: any;

                                                                                                                                                                                                      variable listProps

                                                                                                                                                                                                      const listProps: {
                                                                                                                                                                                                      error: BooleanConstructor;
                                                                                                                                                                                                      offset: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                      loading: BooleanConstructor;
                                                                                                                                                                                                      disabled: BooleanConstructor;
                                                                                                                                                                                                      finished: BooleanConstructor;
                                                                                                                                                                                                      scroller: PropType<Element>;
                                                                                                                                                                                                      errorText: StringConstructor;
                                                                                                                                                                                                      direction: { type: PropType<ListDirection>; default: ListDirection };
                                                                                                                                                                                                      loadingText: StringConstructor;
                                                                                                                                                                                                      finishedText: StringConstructor;
                                                                                                                                                                                                      immediateCheck: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                      };

                                                                                                                                                                                                        variable Loading

                                                                                                                                                                                                        const Loading: any;

                                                                                                                                                                                                          variable loadingProps

                                                                                                                                                                                                          const loadingProps: {
                                                                                                                                                                                                          size: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                          type: { type: import('vue').PropType<LoadingType>; default: LoadingType };
                                                                                                                                                                                                          color: StringConstructor;
                                                                                                                                                                                                          vertical: BooleanConstructor;
                                                                                                                                                                                                          textSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                          textColor: StringConstructor;
                                                                                                                                                                                                          };

                                                                                                                                                                                                            variable Locale

                                                                                                                                                                                                            const Locale: {
                                                                                                                                                                                                            messages(): Message;
                                                                                                                                                                                                            use(newLang: string, newMessages?: Message): void;
                                                                                                                                                                                                            add(newMessages?: Message): void;
                                                                                                                                                                                                            };
                                                                                                                                                                                                              const NavBar: any;
                                                                                                                                                                                                                const navBarProps: {
                                                                                                                                                                                                                title: StringConstructor;
                                                                                                                                                                                                                fixed: BooleanConstructor;
                                                                                                                                                                                                                zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                border: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                leftText: StringConstructor;
                                                                                                                                                                                                                rightText: StringConstructor;
                                                                                                                                                                                                                leftDisabled: BooleanConstructor;
                                                                                                                                                                                                                rightDisabled: BooleanConstructor;
                                                                                                                                                                                                                leftArrow: BooleanConstructor;
                                                                                                                                                                                                                placeholder: BooleanConstructor;
                                                                                                                                                                                                                safeAreaInsetTop: BooleanConstructor;
                                                                                                                                                                                                                clickable: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  variable NoticeBar

                                                                                                                                                                                                                  const NoticeBar: any;

                                                                                                                                                                                                                    variable noticeBarProps

                                                                                                                                                                                                                    const noticeBarProps: {
                                                                                                                                                                                                                    text: StringConstructor;
                                                                                                                                                                                                                    mode: PropType<NoticeBarMode>;
                                                                                                                                                                                                                    color: StringConstructor;
                                                                                                                                                                                                                    delay: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                    speed: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                    leftIcon: StringConstructor;
                                                                                                                                                                                                                    wrapable: BooleanConstructor;
                                                                                                                                                                                                                    background: StringConstructor;
                                                                                                                                                                                                                    scrollable: { type: PropType<boolean | null>; default: null };
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      variable Notify

                                                                                                                                                                                                                      const Notify: any;

                                                                                                                                                                                                                        variable notifyProps

                                                                                                                                                                                                                        const notifyProps: {
                                                                                                                                                                                                                        show: BooleanConstructor;
                                                                                                                                                                                                                        zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                        overlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                        duration: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                        teleport: any;
                                                                                                                                                                                                                        lockScroll: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                        lazyRender: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                        beforeClose: any;
                                                                                                                                                                                                                        overlayStyle: any;
                                                                                                                                                                                                                        overlayClass: any;
                                                                                                                                                                                                                        transitionAppear: BooleanConstructor;
                                                                                                                                                                                                                        closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                        } & {
                                                                                                                                                                                                                        type: { type: import('vue').PropType<NotifyType>; default: NotifyType };
                                                                                                                                                                                                                        color: StringConstructor;
                                                                                                                                                                                                                        message: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                        position: {
                                                                                                                                                                                                                        type: import('vue').PropType<NotifyPosition>;
                                                                                                                                                                                                                        default: NotifyPosition;
                                                                                                                                                                                                                        };
                                                                                                                                                                                                                        className: any;
                                                                                                                                                                                                                        background: StringConstructor;
                                                                                                                                                                                                                        lockScroll: BooleanConstructor;
                                                                                                                                                                                                                        };

                                                                                                                                                                                                                          variable NumberKeyboard

                                                                                                                                                                                                                          const NumberKeyboard: any;

                                                                                                                                                                                                                            variable numberKeyboardProps

                                                                                                                                                                                                                            const numberKeyboardProps: {
                                                                                                                                                                                                                            show: BooleanConstructor;
                                                                                                                                                                                                                            title: StringConstructor;
                                                                                                                                                                                                                            theme: { type: PropType<NumberKeyboardTheme>; default: NumberKeyboardTheme };
                                                                                                                                                                                                                            zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                            teleport: PropType<any>;
                                                                                                                                                                                                                            maxlength: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                            modelValue: { type: PropType<string>; default: string };
                                                                                                                                                                                                                            transition: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                            blurOnClose: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                            showDeleteKey: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                            randomKeyOrder: BooleanConstructor;
                                                                                                                                                                                                                            closeButtonText: StringConstructor;
                                                                                                                                                                                                                            deleteButtonText: StringConstructor;
                                                                                                                                                                                                                            closeButtonLoading: BooleanConstructor;
                                                                                                                                                                                                                            hideOnClickOutside: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                            safeAreaInsetBottom: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                            extraKey: { type: PropType<string | string[]>; default: string };
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              variable Overlay

                                                                                                                                                                                                                              const Overlay: any;

                                                                                                                                                                                                                                variable overlayProps

                                                                                                                                                                                                                                const overlayProps: {
                                                                                                                                                                                                                                show: BooleanConstructor;
                                                                                                                                                                                                                                zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                duration: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                className: PropType<unknown>;
                                                                                                                                                                                                                                lockScroll: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                lazyRender: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                customStyle: PropType<CSSProperties>;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  variable Pagination

                                                                                                                                                                                                                                  const Pagination: any;

                                                                                                                                                                                                                                    variable paginationProps

                                                                                                                                                                                                                                    const paginationProps: {
                                                                                                                                                                                                                                    mode: { type: import('vue').PropType<PaginationMode>; default: PaginationMode };
                                                                                                                                                                                                                                    prevText: StringConstructor;
                                                                                                                                                                                                                                    nextText: StringConstructor;
                                                                                                                                                                                                                                    pageCount: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                    modelValue: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                    totalItems: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                    showPageSize: {
                                                                                                                                                                                                                                    type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                    default: number;
                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                    itemsPerPage: {
                                                                                                                                                                                                                                    type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                    default: number;
                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                    forceEllipses: BooleanConstructor;
                                                                                                                                                                                                                                    showPrevButton: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                    showNextButton: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      variable PasswordInput

                                                                                                                                                                                                                                      const PasswordInput: any;

                                                                                                                                                                                                                                        variable passwordInputProps

                                                                                                                                                                                                                                        const passwordInputProps: {
                                                                                                                                                                                                                                        info: StringConstructor;
                                                                                                                                                                                                                                        mask: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                        value: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                        gutter: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                        length: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                        focused: BooleanConstructor;
                                                                                                                                                                                                                                        errorInfo: StringConstructor;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          variable Picker

                                                                                                                                                                                                                                          const Picker: any;

                                                                                                                                                                                                                                            variable PickerGroup

                                                                                                                                                                                                                                            const PickerGroup: any;

                                                                                                                                                                                                                                              variable pickerGroupProps

                                                                                                                                                                                                                                              const pickerGroupProps: {
                                                                                                                                                                                                                                              tabs: { type: import('vue').PropType<string[]>; default: () => never[] };
                                                                                                                                                                                                                                              activeTab: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                              nextStepText: StringConstructor;
                                                                                                                                                                                                                                              showToolbar: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                              } & {
                                                                                                                                                                                                                                              title: StringConstructor;
                                                                                                                                                                                                                                              cancelButtonText: StringConstructor;
                                                                                                                                                                                                                                              confirmButtonText: StringConstructor;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                variable pickerProps

                                                                                                                                                                                                                                                const pickerProps: {
                                                                                                                                                                                                                                                loading: BooleanConstructor;
                                                                                                                                                                                                                                                readonly: BooleanConstructor;
                                                                                                                                                                                                                                                allowHtml: BooleanConstructor;
                                                                                                                                                                                                                                                optionHeight: {
                                                                                                                                                                                                                                                type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                default: number;
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                showToolbar: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                swipeDuration: {
                                                                                                                                                                                                                                                type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                default: number;
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                visibleOptionNum: {
                                                                                                                                                                                                                                                type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                default: number;
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                } & {
                                                                                                                                                                                                                                                title: StringConstructor;
                                                                                                                                                                                                                                                cancelButtonText: StringConstructor;
                                                                                                                                                                                                                                                confirmButtonText: StringConstructor;
                                                                                                                                                                                                                                                } & {
                                                                                                                                                                                                                                                columns: {
                                                                                                                                                                                                                                                type: PropType<(PickerColumn | PickerOption)[]>;
                                                                                                                                                                                                                                                default: () => never[];
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                modelValue: { type: PropType<Numeric[]>; default: () => never[] };
                                                                                                                                                                                                                                                toolbarPosition: {
                                                                                                                                                                                                                                                type: PropType<PickerToolbarPosition>;
                                                                                                                                                                                                                                                default: PickerToolbarPosition;
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                columnsFieldNames: PropType<PickerFieldNames>;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  variable Popover

                                                                                                                                                                                                                                                  const Popover: any;

                                                                                                                                                                                                                                                    variable popoverProps

                                                                                                                                                                                                                                                    const popoverProps: {
                                                                                                                                                                                                                                                    show: BooleanConstructor;
                                                                                                                                                                                                                                                    theme: { type: PropType<PopoverTheme>; default: PopoverTheme };
                                                                                                                                                                                                                                                    overlay: BooleanConstructor;
                                                                                                                                                                                                                                                    actions: { type: PropType<PopoverAction[]>; default: () => never[] };
                                                                                                                                                                                                                                                    actionsDirection: {
                                                                                                                                                                                                                                                    type: PropType<PopoverActionsDirection>;
                                                                                                                                                                                                                                                    default: PopoverActionsDirection;
                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                    trigger: { type: PropType<PopoverTrigger>; default: PopoverTrigger };
                                                                                                                                                                                                                                                    duration: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                    showArrow: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                    placement: { type: PropType<PopoverPlacement>; default: PopoverPlacement };
                                                                                                                                                                                                                                                    iconPrefix: StringConstructor;
                                                                                                                                                                                                                                                    overlayClass: PropType<unknown>;
                                                                                                                                                                                                                                                    overlayStyle: PropType<CSSProperties>;
                                                                                                                                                                                                                                                    closeOnClickAction: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                    closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                    closeOnClickOutside: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                    offset: { type: PropType<[number, number]>; default: () => number[] };
                                                                                                                                                                                                                                                    teleport: {
                                                                                                                                                                                                                                                    type: PropType<string | import('vue').RendererElement | null | undefined>;
                                                                                                                                                                                                                                                    default: string;
                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                      const Popup: any;

                                                                                                                                                                                                                                                        variable popupProps

                                                                                                                                                                                                                                                        const popupProps: {
                                                                                                                                                                                                                                                        show: BooleanConstructor;
                                                                                                                                                                                                                                                        zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                        overlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                        duration: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                        teleport: any;
                                                                                                                                                                                                                                                        lockScroll: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                        lazyRender: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                        beforeClose: any;
                                                                                                                                                                                                                                                        overlayStyle: any;
                                                                                                                                                                                                                                                        overlayClass: any;
                                                                                                                                                                                                                                                        transitionAppear: BooleanConstructor;
                                                                                                                                                                                                                                                        closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                        } & {
                                                                                                                                                                                                                                                        round: BooleanConstructor;
                                                                                                                                                                                                                                                        position: {
                                                                                                                                                                                                                                                        type: import('vue').PropType<PopupPosition>;
                                                                                                                                                                                                                                                        default: PopupPosition;
                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                        closeIcon: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                        closeable: BooleanConstructor;
                                                                                                                                                                                                                                                        transition: StringConstructor;
                                                                                                                                                                                                                                                        iconPrefix: StringConstructor;
                                                                                                                                                                                                                                                        closeOnPopstate: BooleanConstructor;
                                                                                                                                                                                                                                                        closeIconPosition: {
                                                                                                                                                                                                                                                        type: import('vue').PropType<PopupCloseIconPosition>;
                                                                                                                                                                                                                                                        default: PopupCloseIconPosition;
                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                        safeAreaInsetTop: BooleanConstructor;
                                                                                                                                                                                                                                                        safeAreaInsetBottom: BooleanConstructor;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          variable Progress

                                                                                                                                                                                                                                                          const Progress: any;

                                                                                                                                                                                                                                                            variable progressProps

                                                                                                                                                                                                                                                            const progressProps: {
                                                                                                                                                                                                                                                            color: StringConstructor;
                                                                                                                                                                                                                                                            inactive: BooleanConstructor;
                                                                                                                                                                                                                                                            pivotText: StringConstructor;
                                                                                                                                                                                                                                                            textColor: StringConstructor;
                                                                                                                                                                                                                                                            showPivot: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                            pivotColor: StringConstructor;
                                                                                                                                                                                                                                                            trackColor: StringConstructor;
                                                                                                                                                                                                                                                            strokeWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                            percentage: {
                                                                                                                                                                                                                                                            type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                            default: number;
                                                                                                                                                                                                                                                            validator: (value: Numeric) => boolean;
                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              variable PullRefresh

                                                                                                                                                                                                                                                              const PullRefresh: any;

                                                                                                                                                                                                                                                                variable pullRefreshProps

                                                                                                                                                                                                                                                                const pullRefreshProps: {
                                                                                                                                                                                                                                                                disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                modelValue: BooleanConstructor;
                                                                                                                                                                                                                                                                headHeight: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                successText: StringConstructor;
                                                                                                                                                                                                                                                                pullingText: StringConstructor;
                                                                                                                                                                                                                                                                loosingText: StringConstructor;
                                                                                                                                                                                                                                                                loadingText: StringConstructor;
                                                                                                                                                                                                                                                                pullDistance: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                successDuration: {
                                                                                                                                                                                                                                                                type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                default: number;
                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                animationDuration: {
                                                                                                                                                                                                                                                                type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                default: number;
                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                  variable Radio

                                                                                                                                                                                                                                                                  const Radio: any;

                                                                                                                                                                                                                                                                    variable RadioGroup

                                                                                                                                                                                                                                                                    const RadioGroup: any;

                                                                                                                                                                                                                                                                      variable radioGroupProps

                                                                                                                                                                                                                                                                      const radioGroupProps: {
                                                                                                                                                                                                                                                                      shape: PropType<RadioShape>;
                                                                                                                                                                                                                                                                      disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                      iconSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                      direction: PropType<CheckerDirection>;
                                                                                                                                                                                                                                                                      modelValue: PropType<unknown>;
                                                                                                                                                                                                                                                                      checkedColor: StringConstructor;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        variable radioProps

                                                                                                                                                                                                                                                                        const radioProps: {
                                                                                                                                                                                                                                                                        name: PropType<unknown>;
                                                                                                                                                                                                                                                                        disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                        iconSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                        modelValue: PropType<unknown>;
                                                                                                                                                                                                                                                                        checkedColor: StringConstructor;
                                                                                                                                                                                                                                                                        labelPosition: PropType<CheckerLabelPosition>;
                                                                                                                                                                                                                                                                        labelDisabled: BooleanConstructor;
                                                                                                                                                                                                                                                                        } & { shape: PropType<RadioShape> };

                                                                                                                                                                                                                                                                          variable Rate

                                                                                                                                                                                                                                                                          const Rate: any;

                                                                                                                                                                                                                                                                            variable rateProps

                                                                                                                                                                                                                                                                            const rateProps: {
                                                                                                                                                                                                                                                                            size: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                            icon: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                            color: StringConstructor;
                                                                                                                                                                                                                                                                            count: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                            gutter: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                            clearable: BooleanConstructor;
                                                                                                                                                                                                                                                                            readonly: BooleanConstructor;
                                                                                                                                                                                                                                                                            disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                            voidIcon: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                            allowHalf: BooleanConstructor;
                                                                                                                                                                                                                                                                            voidColor: StringConstructor;
                                                                                                                                                                                                                                                                            touchable: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                            iconPrefix: StringConstructor;
                                                                                                                                                                                                                                                                            modelValue: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                            disabledColor: StringConstructor;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              variable RollingText

                                                                                                                                                                                                                                                                              const RollingText: any;

                                                                                                                                                                                                                                                                                variable rollingTextProps

                                                                                                                                                                                                                                                                                const rollingTextProps: {
                                                                                                                                                                                                                                                                                startNum: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                targetNum: NumberConstructor;
                                                                                                                                                                                                                                                                                textList: { type: import('vue').PropType<string[]>; default: () => never[] };
                                                                                                                                                                                                                                                                                duration: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                autoStart: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                direction: {
                                                                                                                                                                                                                                                                                type: import('vue').PropType<RollingTextDirection>;
                                                                                                                                                                                                                                                                                default: RollingTextDirection;
                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                stopOrder: {
                                                                                                                                                                                                                                                                                type: import('vue').PropType<RollingTextStopOrder>;
                                                                                                                                                                                                                                                                                default: RollingTextStopOrder;
                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                height: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  variable Row

                                                                                                                                                                                                                                                                                  const Row: any;

                                                                                                                                                                                                                                                                                    variable rowProps

                                                                                                                                                                                                                                                                                    const rowProps: {
                                                                                                                                                                                                                                                                                    tag: {
                                                                                                                                                                                                                                                                                    type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                                                                                                                                    default: keyof HTMLElementTagNameMap;
                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                    wrap: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                    align: PropType<RowAlign>;
                                                                                                                                                                                                                                                                                    gutter: {
                                                                                                                                                                                                                                                                                    type: PropType<string | number | (string | number)[]>;
                                                                                                                                                                                                                                                                                    default: number;
                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                    justify: PropType<RowJustify>;
                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                      const Search: any;

                                                                                                                                                                                                                                                                                        variable searchProps

                                                                                                                                                                                                                                                                                        const searchProps: {
                                                                                                                                                                                                                                                                                        id: StringConstructor;
                                                                                                                                                                                                                                                                                        name: StringConstructor;
                                                                                                                                                                                                                                                                                        leftIcon: StringConstructor;
                                                                                                                                                                                                                                                                                        rightIcon: StringConstructor;
                                                                                                                                                                                                                                                                                        autofocus: BooleanConstructor;
                                                                                                                                                                                                                                                                                        clearable: BooleanConstructor;
                                                                                                                                                                                                                                                                                        maxlength: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                        formatter: any;
                                                                                                                                                                                                                                                                                        clearIcon: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                        modelValue: { type: (NumberConstructor | StringConstructor)[]; default: string };
                                                                                                                                                                                                                                                                                        inputAlign: any;
                                                                                                                                                                                                                                                                                        placeholder: StringConstructor;
                                                                                                                                                                                                                                                                                        autocomplete: StringConstructor;
                                                                                                                                                                                                                                                                                        autocapitalize: StringConstructor;
                                                                                                                                                                                                                                                                                        autocorrect: StringConstructor;
                                                                                                                                                                                                                                                                                        errorMessage: StringConstructor;
                                                                                                                                                                                                                                                                                        enterkeyhint: StringConstructor;
                                                                                                                                                                                                                                                                                        clearTrigger: {
                                                                                                                                                                                                                                                                                        type: import('vue').PropType<import('../field').FieldClearTrigger>;
                                                                                                                                                                                                                                                                                        default: import('../field').FieldClearTrigger;
                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                        formatTrigger: {
                                                                                                                                                                                                                                                                                        type: import('vue').PropType<import('../field').FieldFormatTrigger>;
                                                                                                                                                                                                                                                                                        default: import('../field').FieldFormatTrigger;
                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                        spellcheck: { type: BooleanConstructor; default: null };
                                                                                                                                                                                                                                                                                        error: { type: BooleanConstructor; default: null };
                                                                                                                                                                                                                                                                                        disabled: { type: BooleanConstructor; default: null };
                                                                                                                                                                                                                                                                                        readonly: { type: BooleanConstructor; default: null };
                                                                                                                                                                                                                                                                                        } & {
                                                                                                                                                                                                                                                                                        label: StringConstructor;
                                                                                                                                                                                                                                                                                        shape: { type: import('vue').PropType<SearchShape>; default: SearchShape };
                                                                                                                                                                                                                                                                                        leftIcon: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                        clearable: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                        actionText: StringConstructor;
                                                                                                                                                                                                                                                                                        background: StringConstructor;
                                                                                                                                                                                                                                                                                        showAction: BooleanConstructor;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          variable ShareSheet

                                                                                                                                                                                                                                                                                          const ShareSheet: any;

                                                                                                                                                                                                                                                                                            variable shareSheetProps

                                                                                                                                                                                                                                                                                            const shareSheetProps: {
                                                                                                                                                                                                                                                                                            show: BooleanConstructor;
                                                                                                                                                                                                                                                                                            zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                            overlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                            duration: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                            teleport: any;
                                                                                                                                                                                                                                                                                            lockScroll: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                            lazyRender: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                            beforeClose: any;
                                                                                                                                                                                                                                                                                            overlayStyle: any;
                                                                                                                                                                                                                                                                                            overlayClass: any;
                                                                                                                                                                                                                                                                                            transitionAppear: BooleanConstructor;
                                                                                                                                                                                                                                                                                            closeOnClickOverlay: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                            } & {
                                                                                                                                                                                                                                                                                            title: StringConstructor;
                                                                                                                                                                                                                                                                                            round: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                            options: {
                                                                                                                                                                                                                                                                                            type: import('vue').PropType<(ShareSheetOption | ShareSheetOption[])[]>;
                                                                                                                                                                                                                                                                                            default: () => never[];
                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                            cancelText: StringConstructor;
                                                                                                                                                                                                                                                                                            description: StringConstructor;
                                                                                                                                                                                                                                                                                            closeOnPopstate: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                            safeAreaInsetBottom: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                              const Sidebar: any;

                                                                                                                                                                                                                                                                                                variable SidebarItem

                                                                                                                                                                                                                                                                                                const SidebarItem: any;

                                                                                                                                                                                                                                                                                                  variable sidebarItemProps

                                                                                                                                                                                                                                                                                                  const sidebarItemProps: {
                                                                                                                                                                                                                                                                                                  to: PropType<any>;
                                                                                                                                                                                                                                                                                                  url: StringConstructor;
                                                                                                                                                                                                                                                                                                  replace: BooleanConstructor;
                                                                                                                                                                                                                                                                                                  } & {
                                                                                                                                                                                                                                                                                                  dot: BooleanConstructor;
                                                                                                                                                                                                                                                                                                  title: StringConstructor;
                                                                                                                                                                                                                                                                                                  badge: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                  disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                  badgeProps: PropType<
                                                                                                                                                                                                                                                                                                  ExtractPropTypes<{
                                                                                                                                                                                                                                                                                                  dot: BooleanConstructor;
                                                                                                                                                                                                                                                                                                  max: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                                                                                                                                                  tag: {
                                                                                                                                                                                                                                                                                                  type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                                                                                                                                                  default: keyof HTMLElementTagNameMap;
                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                  color: StringConstructor;
                                                                                                                                                                                                                                                                                                  offset: PropType<[Numeric, Numeric]>;
                                                                                                                                                                                                                                                                                                  content: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                                                                                                                                                  showZero: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                  position: { type: PropType<BadgePosition>; default: BadgePosition };
                                                                                                                                                                                                                                                                                                  }>
                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    variable sidebarProps

                                                                                                                                                                                                                                                                                                    const sidebarProps: {
                                                                                                                                                                                                                                                                                                    modelValue: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      variable Signature

                                                                                                                                                                                                                                                                                                      const Signature: any;

                                                                                                                                                                                                                                                                                                        variable Skeleton

                                                                                                                                                                                                                                                                                                        const Skeleton: any;

                                                                                                                                                                                                                                                                                                          variable SkeletonAvatar

                                                                                                                                                                                                                                                                                                          const SkeletonAvatar: any;

                                                                                                                                                                                                                                                                                                            variable skeletonAvatarProps

                                                                                                                                                                                                                                                                                                            const skeletonAvatarProps: {
                                                                                                                                                                                                                                                                                                            avatarSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                            avatarShape: {
                                                                                                                                                                                                                                                                                                            type: import('vue').PropType<SkeletonAvatarShape>;
                                                                                                                                                                                                                                                                                                            default: SkeletonAvatarShape;
                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              variable SkeletonImage

                                                                                                                                                                                                                                                                                                              const SkeletonImage: any;

                                                                                                                                                                                                                                                                                                                variable skeletonImageProps

                                                                                                                                                                                                                                                                                                                const skeletonImageProps: {
                                                                                                                                                                                                                                                                                                                imageSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                imageShape: {
                                                                                                                                                                                                                                                                                                                type: import('vue').PropType<SkeletonImageShape>;
                                                                                                                                                                                                                                                                                                                default: SkeletonImageShape;
                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                  variable SkeletonParagraph

                                                                                                                                                                                                                                                                                                                  const SkeletonParagraph: any;

                                                                                                                                                                                                                                                                                                                    variable skeletonParagraphProps

                                                                                                                                                                                                                                                                                                                    const skeletonParagraphProps: {
                                                                                                                                                                                                                                                                                                                    round: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                    rowWidth: { type: (NumberConstructor | StringConstructor)[]; default: string };
                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                      variable skeletonProps

                                                                                                                                                                                                                                                                                                                      const skeletonProps: {
                                                                                                                                                                                                                                                                                                                      row: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                      round: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                      title: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                      titleWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                      avatar: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                      avatarSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                      avatarShape: {
                                                                                                                                                                                                                                                                                                                      type: PropType<SkeletonAvatarShape>;
                                                                                                                                                                                                                                                                                                                      default: SkeletonAvatarShape;
                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                      loading: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                      animate: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                      rowWidth: { type: PropType<Numeric | Numeric[]>; default: string };
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        variable SkeletonTitle

                                                                                                                                                                                                                                                                                                                        const SkeletonTitle: any;

                                                                                                                                                                                                                                                                                                                          variable skeletonTitleProps

                                                                                                                                                                                                                                                                                                                          const skeletonTitleProps: {
                                                                                                                                                                                                                                                                                                                          round: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                          titleWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            variable Slider

                                                                                                                                                                                                                                                                                                                            const Slider: any;

                                                                                                                                                                                                                                                                                                                              variable sliderProps

                                                                                                                                                                                                                                                                                                                              const sliderProps: {
                                                                                                                                                                                                                                                                                                                              min: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                              max: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                              step: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                              range: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                              reverse: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                              disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                              readonly: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                              vertical: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                              barHeight: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                              buttonSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                              activeColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                              inactiveColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                              modelValue: { type: PropType<SliderValue>; default: number };
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                variable Space

                                                                                                                                                                                                                                                                                                                                const Space: any;

                                                                                                                                                                                                                                                                                                                                  variable spaceProps

                                                                                                                                                                                                                                                                                                                                  const spaceProps: {
                                                                                                                                                                                                                                                                                                                                  align: PropType<SpaceAlign>;
                                                                                                                                                                                                                                                                                                                                  direction: { type: PropType<'horizontal' | 'vertical'>; default: string };
                                                                                                                                                                                                                                                                                                                                  size: {
                                                                                                                                                                                                                                                                                                                                  type: PropType<string | number | [SpaceSize, SpaceSize]>;
                                                                                                                                                                                                                                                                                                                                  default: number;
                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                  wrap: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                  fill: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                    variable Step

                                                                                                                                                                                                                                                                                                                                    const Step: any;

                                                                                                                                                                                                                                                                                                                                      variable Stepper

                                                                                                                                                                                                                                                                                                                                      const Stepper: any;

                                                                                                                                                                                                                                                                                                                                        variable stepperProps

                                                                                                                                                                                                                                                                                                                                        const stepperProps: {
                                                                                                                                                                                                                                                                                                                                        min: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                        max: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                        name: { type: (NumberConstructor | StringConstructor)[]; default: string };
                                                                                                                                                                                                                                                                                                                                        step: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                        theme: PropType<StepperTheme>;
                                                                                                                                                                                                                                                                                                                                        integer: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                        disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                        showPlus: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                        showMinus: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                        showInput: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                        longPress: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                        autoFixed: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                        allowEmpty: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                        modelValue: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                        inputWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                        buttonSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                        placeholder: StringConstructor;
                                                                                                                                                                                                                                                                                                                                        disablePlus: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                        disableMinus: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                        disableInput: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                        beforeChange: PropType<Interceptor>;
                                                                                                                                                                                                                                                                                                                                        defaultValue: {
                                                                                                                                                                                                                                                                                                                                        type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                        default: number;
                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                        decimalLength: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                          variable Steps

                                                                                                                                                                                                                                                                                                                                          const Steps: any;

                                                                                                                                                                                                                                                                                                                                            variable stepsProps

                                                                                                                                                                                                                                                                                                                                            const stepsProps: {
                                                                                                                                                                                                                                                                                                                                            active: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                            direction: {
                                                                                                                                                                                                                                                                                                                                            type: import('vue').PropType<StepsDirection>;
                                                                                                                                                                                                                                                                                                                                            default: StepsDirection;
                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                            activeIcon: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                            iconPrefix: StringConstructor;
                                                                                                                                                                                                                                                                                                                                            finishIcon: StringConstructor;
                                                                                                                                                                                                                                                                                                                                            activeColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                            inactiveIcon: StringConstructor;
                                                                                                                                                                                                                                                                                                                                            inactiveColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                              variable Sticky

                                                                                                                                                                                                                                                                                                                                              const Sticky: any;

                                                                                                                                                                                                                                                                                                                                                variable stickyProps

                                                                                                                                                                                                                                                                                                                                                const stickyProps: {
                                                                                                                                                                                                                                                                                                                                                zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                position: { type: PropType<StickyPosition>; default: StickyPosition };
                                                                                                                                                                                                                                                                                                                                                container: PropType<Element>;
                                                                                                                                                                                                                                                                                                                                                offsetTop: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                offsetBottom: {
                                                                                                                                                                                                                                                                                                                                                type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                default: number;
                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                  variable SubmitBar

                                                                                                                                                                                                                                                                                                                                                  const SubmitBar: any;

                                                                                                                                                                                                                                                                                                                                                    variable submitBarProps

                                                                                                                                                                                                                                                                                                                                                    const submitBarProps: {
                                                                                                                                                                                                                                                                                                                                                    tip: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                    label: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                    price: NumberConstructor;
                                                                                                                                                                                                                                                                                                                                                    tipIcon: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                    loading: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                    currency: { type: PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                    disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                    textAlign: PropType<SubmitBarTextAlign>;
                                                                                                                                                                                                                                                                                                                                                    buttonText: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                    buttonType: { type: PropType<ButtonType>; default: ButtonType };
                                                                                                                                                                                                                                                                                                                                                    buttonColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                    suffixLabel: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                    placeholder: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                    decimalLength: {
                                                                                                                                                                                                                                                                                                                                                    type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                    default: number;
                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                    safeAreaInsetBottom: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                      variable Swipe

                                                                                                                                                                                                                                                                                                                                                      const Swipe: any;

                                                                                                                                                                                                                                                                                                                                                        variable SwipeCell

                                                                                                                                                                                                                                                                                                                                                        const SwipeCell: any;

                                                                                                                                                                                                                                                                                                                                                          variable swipeCellProps

                                                                                                                                                                                                                                                                                                                                                          const swipeCellProps: {
                                                                                                                                                                                                                                                                                                                                                          name: { type: (NumberConstructor | StringConstructor)[]; default: string };
                                                                                                                                                                                                                                                                                                                                                          disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                          leftWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                          rightWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                          beforeClose: PropType<Interceptor>;
                                                                                                                                                                                                                                                                                                                                                          stopPropagation: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                            variable SwipeItem

                                                                                                                                                                                                                                                                                                                                                            const SwipeItem: any;

                                                                                                                                                                                                                                                                                                                                                              variable swipeProps

                                                                                                                                                                                                                                                                                                                                                              const swipeProps: {
                                                                                                                                                                                                                                                                                                                                                              loop: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                              width: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                              height: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                              vertical: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                              autoplay: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                              duration: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                              touchable: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                              lazyRender: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                              initialSwipe: {
                                                                                                                                                                                                                                                                                                                                                              type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                              default: number;
                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                              indicatorColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                              showIndicators: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                              stopPropagation: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                variable Switch

                                                                                                                                                                                                                                                                                                                                                                const Switch: any;

                                                                                                                                                                                                                                                                                                                                                                  variable switchProps

                                                                                                                                                                                                                                                                                                                                                                  const switchProps: {
                                                                                                                                                                                                                                                                                                                                                                  size: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                  loading: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                  disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                  modelValue: any;
                                                                                                                                                                                                                                                                                                                                                                  activeColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                  inactiveColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                  activeValue: { type: import('vue').PropType<unknown>; default: unknown };
                                                                                                                                                                                                                                                                                                                                                                  inactiveValue: { type: import('vue').PropType<unknown>; default: unknown };
                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                    variable Tab

                                                                                                                                                                                                                                                                                                                                                                    const Tab: any;

                                                                                                                                                                                                                                                                                                                                                                      variable Tabbar

                                                                                                                                                                                                                                                                                                                                                                      const Tabbar: any;

                                                                                                                                                                                                                                                                                                                                                                        variable TabbarItem

                                                                                                                                                                                                                                                                                                                                                                        const TabbarItem: any;

                                                                                                                                                                                                                                                                                                                                                                          variable tabbarItemProps

                                                                                                                                                                                                                                                                                                                                                                          const tabbarItemProps: {
                                                                                                                                                                                                                                                                                                                                                                          to: PropType<any>;
                                                                                                                                                                                                                                                                                                                                                                          url: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                          replace: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                          } & {
                                                                                                                                                                                                                                                                                                                                                                          dot: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                          icon: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                          name: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                          badge: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                          badgeProps: PropType<
                                                                                                                                                                                                                                                                                                                                                                          ExtractPropTypes<{
                                                                                                                                                                                                                                                                                                                                                                          dot: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                          max: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                          tag: {
                                                                                                                                                                                                                                                                                                                                                                          type: PropType<keyof HTMLElementTagNameMap>;
                                                                                                                                                                                                                                                                                                                                                                          default: keyof HTMLElementTagNameMap;
                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                          color: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                          offset: PropType<[Numeric, Numeric]>;
                                                                                                                                                                                                                                                                                                                                                                          content: (StringConstructor | NumberConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                          showZero: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                          position: { type: PropType<BadgePosition>; default: BadgePosition };
                                                                                                                                                                                                                                                                                                                                                                          }>
                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                          iconPrefix: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                            variable tabbarProps

                                                                                                                                                                                                                                                                                                                                                                            const tabbarProps: {
                                                                                                                                                                                                                                                                                                                                                                            route: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                            fixed: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                            border: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                            zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                            placeholder: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                            activeColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                            beforeChange: PropType<Interceptor>;
                                                                                                                                                                                                                                                                                                                                                                            inactiveColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                            modelValue: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                            safeAreaInsetBottom: { type: PropType<boolean | null>; default: null };
                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                              variable tabProps

                                                                                                                                                                                                                                                                                                                                                                              const tabProps: {
                                                                                                                                                                                                                                                                                                                                                                              to: PropType<any>;
                                                                                                                                                                                                                                                                                                                                                                              url: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                              replace: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                              } & {
                                                                                                                                                                                                                                                                                                                                                                              dot: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                              name: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                              badge: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                              title: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                              disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                              titleClass: PropType<unknown>;
                                                                                                                                                                                                                                                                                                                                                                              titleStyle: PropType<any>;
                                                                                                                                                                                                                                                                                                                                                                              showZeroBadge: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                variable Tabs

                                                                                                                                                                                                                                                                                                                                                                                const Tabs: any;

                                                                                                                                                                                                                                                                                                                                                                                  variable tabsProps

                                                                                                                                                                                                                                                                                                                                                                                  const tabsProps: {
                                                                                                                                                                                                                                                                                                                                                                                  type: { type: PropType<TabsType>; default: TabsType };
                                                                                                                                                                                                                                                                                                                                                                                  color: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  border: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  sticky: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  shrink: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  active: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                  duration: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                  animated: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  ellipsis: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                  swipeable: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  scrollspy: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  offsetTop: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                  background: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  lazyRender: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                  showHeader: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                  lineWidth: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                  lineHeight: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                  beforeChange: PropType<Interceptor>;
                                                                                                                                                                                                                                                                                                                                                                                  swipeThreshold: {
                                                                                                                                                                                                                                                                                                                                                                                  type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                  default: number;
                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                  titleActiveColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  titleInactiveColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                    variable Tag

                                                                                                                                                                                                                                                                                                                                                                                    const Tag: any;

                                                                                                                                                                                                                                                                                                                                                                                      variable tagProps

                                                                                                                                                                                                                                                                                                                                                                                      const tagProps: {
                                                                                                                                                                                                                                                                                                                                                                                      size: PropType<TagSize>;
                                                                                                                                                                                                                                                                                                                                                                                      mark: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                      show: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                      type: { type: PropType<TagType>; default: TagType };
                                                                                                                                                                                                                                                                                                                                                                                      color: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                      plain: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                      round: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                      textColor: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                      closeable: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                        variable TextEllipsis

                                                                                                                                                                                                                                                                                                                                                                                        const TextEllipsis: any;

                                                                                                                                                                                                                                                                                                                                                                                          variable textEllipsisProps

                                                                                                                                                                                                                                                                                                                                                                                          const textEllipsisProps: {
                                                                                                                                                                                                                                                                                                                                                                                          rows: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                          dots: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                          content: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                          expandText: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                          collapseText: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                          position: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                            variable TimePicker

                                                                                                                                                                                                                                                                                                                                                                                            const TimePicker: any;

                                                                                                                                                                                                                                                                                                                                                                                              variable timePickerProps

                                                                                                                                                                                                                                                                                                                                                                                              const timePickerProps: {
                                                                                                                                                                                                                                                                                                                                                                                              loading: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                              readonly: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                              allowHtml: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                              optionHeight: {
                                                                                                                                                                                                                                                                                                                                                                                              type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                              default: number;
                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                              showToolbar: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                              swipeDuration: {
                                                                                                                                                                                                                                                                                                                                                                                              type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                              default: number;
                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                              visibleOptionNum: {
                                                                                                                                                                                                                                                                                                                                                                                              type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                              default: number;
                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                              } & {
                                                                                                                                                                                                                                                                                                                                                                                              title: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                              cancelButtonText: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                              confirmButtonText: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                              } & {
                                                                                                                                                                                                                                                                                                                                                                                              modelValue: { type: PropType<string[]>; default: () => never[] };
                                                                                                                                                                                                                                                                                                                                                                                              filter: PropType<
                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                              columnType: string,
                                                                                                                                                                                                                                                                                                                                                                                              options: import('../picker').PickerOption[],
                                                                                                                                                                                                                                                                                                                                                                                              values?: string[] | undefined
                                                                                                                                                                                                                                                                                                                                                                                              ) => import('../picker').PickerOption[]
                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                              formatter: {
                                                                                                                                                                                                                                                                                                                                                                                              type: PropType<
                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                              type: string,
                                                                                                                                                                                                                                                                                                                                                                                              option: import('../picker').PickerOption
                                                                                                                                                                                                                                                                                                                                                                                              ) => import('../picker').PickerOption
                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                              default: (
                                                                                                                                                                                                                                                                                                                                                                                              type: string,
                                                                                                                                                                                                                                                                                                                                                                                              option: import('../picker').PickerOption
                                                                                                                                                                                                                                                                                                                                                                                              ) => import('../picker').PickerOption;
                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                              } & {
                                                                                                                                                                                                                                                                                                                                                                                              minHour: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                              maxHour: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                              minMinute: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                              maxMinute: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                              minSecond: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                              maxSecond: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                              minTime: { type: StringConstructor; validator: (val: string) => boolean };
                                                                                                                                                                                                                                                                                                                                                                                              maxTime: { type: StringConstructor; validator: (val: string) => boolean };
                                                                                                                                                                                                                                                                                                                                                                                              columnsType: { type: PropType<TimePickerColumnType[]>; default: () => string[] };
                                                                                                                                                                                                                                                                                                                                                                                              filter: PropType<
                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                              columnType: string,
                                                                                                                                                                                                                                                                                                                                                                                              options: import('../picker').PickerOption[],
                                                                                                                                                                                                                                                                                                                                                                                              values: string[]
                                                                                                                                                                                                                                                                                                                                                                                              ) => import('../picker').PickerOption[]
                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                variable Toast

                                                                                                                                                                                                                                                                                                                                                                                                const Toast: any;

                                                                                                                                                                                                                                                                                                                                                                                                  variable toastProps

                                                                                                                                                                                                                                                                                                                                                                                                  const toastProps: {
                                                                                                                                                                                                                                                                                                                                                                                                  icon: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                  show: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                  type: { type: PropType<ToastType>; default: ToastType };
                                                                                                                                                                                                                                                                                                                                                                                                  overlay: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                  message: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                                  iconSize: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                                  duration: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                  position: { type: PropType<ToastPosition>; default: ToastPosition };
                                                                                                                                                                                                                                                                                                                                                                                                  teleport: PropType<any>;
                                                                                                                                                                                                                                                                                                                                                                                                  wordBreak: PropType<ToastWordBreak>;
                                                                                                                                                                                                                                                                                                                                                                                                  className: PropType<unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                  iconPrefix: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                  transition: { type: PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                                  loadingType: PropType<LoadingType>;
                                                                                                                                                                                                                                                                                                                                                                                                  forbidClick: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                  overlayClass: PropType<unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                  overlayStyle: PropType<CSSProperties>;
                                                                                                                                                                                                                                                                                                                                                                                                  closeOnClick: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                  closeOnClickOverlay: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                  zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                    variable TreeSelect

                                                                                                                                                                                                                                                                                                                                                                                                    const TreeSelect: any;

                                                                                                                                                                                                                                                                                                                                                                                                      variable treeSelectProps

                                                                                                                                                                                                                                                                                                                                                                                                      const treeSelectProps: {
                                                                                                                                                                                                                                                                                                                                                                                                      max: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                      items: { type: PropType<TreeSelectItem[]>; default: () => never[] };
                                                                                                                                                                                                                                                                                                                                                                                                      height: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                      selectedIcon: { type: PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                                      mainActiveIndex: {
                                                                                                                                                                                                                                                                                                                                                                                                      type: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                                      default: number;
                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                      activeId: { type: PropType<Numeric | Numeric[]>; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                        variable Uploader

                                                                                                                                                                                                                                                                                                                                                                                                        const Uploader: any;

                                                                                                                                                                                                                                                                                                                                                                                                          variable uploaderProps

                                                                                                                                                                                                                                                                                                                                                                                                          const uploaderProps: {
                                                                                                                                                                                                                                                                                                                                                                                                          name: { type: (NumberConstructor | StringConstructor)[]; default: string };
                                                                                                                                                                                                                                                                                                                                                                                                          accept: { type: PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                                          capture: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                          multiple: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                          disabled: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                          readonly: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                          lazyLoad: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                          maxCount: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                          imageFit: {
                                                                                                                                                                                                                                                                                                                                                                                                          type: PropType<import('csstype').Property.ObjectFit | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                          default: import('csstype').Property.ObjectFit | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                          resultType: { type: PropType<UploaderResultType>; default: UploaderResultType };
                                                                                                                                                                                                                                                                                                                                                                                                          uploadIcon: { type: PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                                          uploadText: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                          deletable: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                                          reupload: BooleanConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                          afterRead: PropType<UploaderAfterRead>;
                                                                                                                                                                                                                                                                                                                                                                                                          showUpload: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                                          modelValue: { type: PropType<UploaderFileListItem[]>; default: () => never[] };
                                                                                                                                                                                                                                                                                                                                                                                                          beforeRead: PropType<UploaderBeforeRead>;
                                                                                                                                                                                                                                                                                                                                                                                                          beforeDelete: PropType<Interceptor>;
                                                                                                                                                                                                                                                                                                                                                                                                          previewSize: PropType<Numeric | [Numeric, Numeric]>;
                                                                                                                                                                                                                                                                                                                                                                                                          previewImage: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                                          previewOptions: PropType<Partial<ImagePreviewOptions>>;
                                                                                                                                                                                                                                                                                                                                                                                                          previewFullImage: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                                          maxSize: { type: PropType<UploaderMaxSize>; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                            variable version

                                                                                                                                                                                                                                                                                                                                                                                                            const version: string;

                                                                                                                                                                                                                                                                                                                                                                                                              variable Watermark

                                                                                                                                                                                                                                                                                                                                                                                                              const Watermark: any;

                                                                                                                                                                                                                                                                                                                                                                                                                variable watermarkProps

                                                                                                                                                                                                                                                                                                                                                                                                                const watermarkProps: {
                                                                                                                                                                                                                                                                                                                                                                                                                gapX: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                                gapY: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                                image: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                                width: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                                height: { type: NumberConstructor; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                                rotate: { type: (NumberConstructor | StringConstructor)[]; default: number };
                                                                                                                                                                                                                                                                                                                                                                                                                zIndex: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                                                content: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                                opacity: (NumberConstructor | StringConstructor)[];
                                                                                                                                                                                                                                                                                                                                                                                                                fullPage: { type: BooleanConstructor; default: true };
                                                                                                                                                                                                                                                                                                                                                                                                                textColor: { type: import('vue').PropType<string>; default: string };
                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                  function allowMultipleToast

                                                                                                                                                                                                                                                                                                                                                                                                                  allowMultipleToast: (value?: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                  • Allow multiple toasts to be displayed as the same time

                                                                                                                                                                                                                                                                                                                                                                                                                  function closeDialog

                                                                                                                                                                                                                                                                                                                                                                                                                  closeDialog: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                  • Close the currently displayed dialog

                                                                                                                                                                                                                                                                                                                                                                                                                  function closeNotify

                                                                                                                                                                                                                                                                                                                                                                                                                  closeNotify: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                  • Close the currently displayed Notify

                                                                                                                                                                                                                                                                                                                                                                                                                  function closeToast

                                                                                                                                                                                                                                                                                                                                                                                                                  closeToast: (all?: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                  • Close the currently displayed toast

                                                                                                                                                                                                                                                                                                                                                                                                                  function install

                                                                                                                                                                                                                                                                                                                                                                                                                  install: (app: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    function resetDialogDefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    resetDialogDefaultOptions: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Reset the default configuration that affects all showDialog calls

                                                                                                                                                                                                                                                                                                                                                                                                                    function resetNotifyDefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    resetNotifyDefaultOptions: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Reset the default configuration, affecting all showNotify calls

                                                                                                                                                                                                                                                                                                                                                                                                                    function resetToastDefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    resetToastDefaultOptions: (type?: ToastType) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Reset the default configuration that affects all showToast calls. Specify the type parameter to reset the default configuration of a specific type of toast

                                                                                                                                                                                                                                                                                                                                                                                                                    function setDialogDefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    setDialogDefaultOptions: (options: DialogOptions) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Modify the default configuration that affects all showDialog calls

                                                                                                                                                                                                                                                                                                                                                                                                                    function setNotifyDefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    setNotifyDefaultOptions: (options: NotifyOptions) => NotifyOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Modify the default configuration, affecting all showNotify calls

                                                                                                                                                                                                                                                                                                                                                                                                                    function setToastDefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    setToastDefaultOptions: {
                                                                                                                                                                                                                                                                                                                                                                                                                    (options: ToastOptions): void;
                                                                                                                                                                                                                                                                                                                                                                                                                    (type: ToastType, options: ToastOptions): void;
                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                    • Modify the default configuration that affects all showToast calls. Specify the type parameter to modify the default configuration of a specific type of toast

                                                                                                                                                                                                                                                                                                                                                                                                                    function showConfirmDialog

                                                                                                                                                                                                                                                                                                                                                                                                                    showConfirmDialog: (options: DialogOptions) => Promise<DialogAction | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display a message confirmation dialog with default confirm and cancel buttons

                                                                                                                                                                                                                                                                                                                                                                                                                    function showDialog

                                                                                                                                                                                                                                                                                                                                                                                                                    showDialog: (options: DialogOptions) => Promise<DialogAction | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display a message prompt dialog with a default confirm button

                                                                                                                                                                                                                                                                                                                                                                                                                    function showFailToast

                                                                                                                                                                                                                                                                                                                                                                                                                    showFailToast: (
                                                                                                                                                                                                                                                                                                                                                                                                                    options: string | ToastOptions
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ComponentPublicInstance<
                                                                                                                                                                                                                                                                                                                                                                                                                    { message: Numeric },
                                                                                                                                                                                                                                                                                                                                                                                                                    { close: () => void; open: (props: Record<string, any>) => void }
                                                                                                                                                                                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display a fail toast

                                                                                                                                                                                                                                                                                                                                                                                                                    function showImagePreview

                                                                                                                                                                                                                                                                                                                                                                                                                    showImagePreview: (
                                                                                                                                                                                                                                                                                                                                                                                                                    options: string[] | ImagePreviewOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                    startPosition?: number
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ComponentInstance | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display a full-screen image preview component

                                                                                                                                                                                                                                                                                                                                                                                                                    function showLoadingToast

                                                                                                                                                                                                                                                                                                                                                                                                                    showLoadingToast: (
                                                                                                                                                                                                                                                                                                                                                                                                                    options: string | ToastOptions
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ComponentPublicInstance<
                                                                                                                                                                                                                                                                                                                                                                                                                    { message: Numeric },
                                                                                                                                                                                                                                                                                                                                                                                                                    { close: () => void; open: (props: Record<string, any>) => void }
                                                                                                                                                                                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display a loading toast

                                                                                                                                                                                                                                                                                                                                                                                                                    function showNotify

                                                                                                                                                                                                                                                                                                                                                                                                                    showNotify: (
                                                                                                                                                                                                                                                                                                                                                                                                                    options: NotifyMessage | NotifyOptions
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ComponentInstance | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display Notify at the top of the page

                                                                                                                                                                                                                                                                                                                                                                                                                    function showSuccessToast

                                                                                                                                                                                                                                                                                                                                                                                                                    showSuccessToast: (
                                                                                                                                                                                                                                                                                                                                                                                                                    options: string | ToastOptions
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ComponentPublicInstance<
                                                                                                                                                                                                                                                                                                                                                                                                                    { message: Numeric },
                                                                                                                                                                                                                                                                                                                                                                                                                    { close: () => void; open: (props: Record<string, any>) => void }
                                                                                                                                                                                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display a success toast

                                                                                                                                                                                                                                                                                                                                                                                                                    function showToast

                                                                                                                                                                                                                                                                                                                                                                                                                    showToast: (
                                                                                                                                                                                                                                                                                                                                                                                                                    options?: string | ToastOptions
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ComponentPublicInstance<
                                                                                                                                                                                                                                                                                                                                                                                                                    { message: Numeric },
                                                                                                                                                                                                                                                                                                                                                                                                                    { close: () => void; open: (props: Record<string, any>) => void }
                                                                                                                                                                                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Display a text toast

                                                                                                                                                                                                                                                                                                                                                                                                                    function useCurrentLang

                                                                                                                                                                                                                                                                                                                                                                                                                    useCurrentLang: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                      Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                      interface BarrageItem

                                                                                                                                                                                                                                                                                                                                                                                                                      interface BarrageItem {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                        id: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                                                                                          text: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                            type ActionBarButtonProps

                                                                                                                                                                                                                                                                                                                                                                                                                            type ActionBarButtonProps = ExtractPropTypes<typeof actionBarButtonProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                              type ActionBarButtonThemeVars

                                                                                                                                                                                                                                                                                                                                                                                                                              type ActionBarButtonThemeVars = {
                                                                                                                                                                                                                                                                                                                                                                                                                              actionBarButtonHeight?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                              actionBarButtonWarningColor?: