vant

vant

Version 4.9.19
Published 11 days ago
6.03 MB
3 dependencies
MIT license

Install

npm i vant

yarn add vant

pnpm add vant

Overview

Mobile UI Components built on Vue

Index

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<TeleportProps>;
    offset: { type: (NumberConstructor | StringConstructor)[]; default: number };
    immediate: BooleanConstructor;
    teleport: { type: PropType<TeleportProps['to']>; 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<TeleportProps>;
    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[]
        ) => 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;
    keyboardEnabled: { type: BooleanConstructor; default: true };
    destroyOnClose: 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;
    };
};

variable DropdownItem

const DropdownItem: any;

variable dropdownItemProps

const dropdownItemProps: {
    title: StringConstructor;
    options: { type: PropType<DropdownItemOption[]>; default: () => never[] };
    disabled: BooleanConstructor;
    teleport: PropType<TeleportProps>;
    lazyRender: { type: BooleanConstructor; default: true };
    modelValue: PropType<unknown>;
    titleClass: PropType<unknown>;
};

variable DropdownMenu

const DropdownMenu: any;

variable dropdownMenuProps

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)[];
    max: NumberConstructor;
    min: NumberConstructor;
    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 };
    inputmode: PropType<HTMLAttributes>;
} & {
    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: PropType<FloatingBubbleGap>; 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<TeleportProps['to']>; 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;
    scrollToErrorPosition: PropType<ScrollLogicalPosition>;
    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<TeleportProps>;
};

variable imageProps

const imageProps: {
    src: StringConstructor;
    alt: StringConstructor;
    fit: PropType<CSSProperties>;
    position: PropType<CSSProperties>;
    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<ImgHTMLAttributes>;
    referrerpolicy: PropType<ImgHTMLAttributes>;
};

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<TeleportProps>;
    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;

variable navBarProps

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<TeleportProps>;
    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>;
    teleport: PropType<TeleportProps>;
};

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>;
};

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<TeleportProps['to']>; 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;
    };
    destroyOnClose: BooleanConstructor;
    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>;
};

variable Search

const Search: any;

variable searchProps

const searchProps: {
    id: StringConstructor;
    name: StringConstructor;
    leftIcon: StringConstructor;
    rightIcon: StringConstructor;
    autofocus: BooleanConstructor;
    clearable: BooleanConstructor;
    maxlength: (NumberConstructor | StringConstructor)[];
    max: NumberConstructor;
    min: NumberConstructor;
    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 };
    inputmode: any;
} & {
    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<'vertical' | 'horizontal'>; default: string };
    size: {
        type: PropType<number | string | [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[]
        ) => 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[] };
};

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<TeleportProps>;
    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?: string;
    actionBarButtonDangerColor?: string;
};

type ActionBarIconProps

type ActionBarIconProps = ExtractPropTypes<typeof actionBarIconProps>;

type ActionBarIconThemeVars

type ActionBarIconThemeVars = {
    actionBarIconWidth?: string;
    actionBarIconHeight?: string;
    actionBarIconColor?: string;
    actionBarIconSize?: string;
    actionBarIconFontSize?: string;
    actionBarIconActiveColor?: string;
    actionBarIconTextColor?: string;
    actionBarIconBackground?: string;
};

type ActionBarProps

type ActionBarProps = ExtractPropTypes<typeof actionBarProps>;

type ActionBarThemeVars

type ActionBarThemeVars = {
    actionBarBackground?: string;
    actionBarHeight?: string;
};

type ActionSheetAction

type ActionSheetAction = {
    icon?: string;
    name?: string;
    color?: string;
    subname?: string;
    loading?: boolean;
    disabled?: boolean;
    callback?: (action: ActionSheetAction) => void;
    className?: unknown;
};

type ActionSheetProps

type ActionSheetProps = ExtractPropTypes<typeof actionSheetProps>;

type ActionSheetThemeVars

type ActionSheetThemeVars = {
    actionSheetMaxHeight?: string;
    actionSheetHeaderHeight?: string;
    actionSheetHeaderFontSize?: string;
    actionSheetDescriptionColor?: string;
    actionSheetDescriptionFontSize?: string;
    actionSheetDescriptionLineHeight?: number | string;
    actionSheetItemBackground?: string;
    actionSheetItemFontSize?: string;
    actionSheetItemLineHeight?: number | string;
    actionSheetItemTextColor?: string;
    actionSheetItemDisabledTextColor?: string;
    actionSheetSubnameColor?: string;
    actionSheetSubnameFontSize?: string;
    actionSheetSubnameLineHeight?: number | string;
    actionSheetCloseIconSize?: string;
    actionSheetCloseIconColor?: string;
    actionSheetCloseIconPadding?: string;
    actionSheetCancelTextColor?: string;
    actionSheetCancelPaddingTop?: string;
    actionSheetCancelPaddingColor?: string;
    actionSheetLoadingIconSize?: string;
};

type AddressEditInfo

type AddressEditInfo = {
    tel: string;
    name: string;
    city: string;
    county: string;
    province: string;
    areaCode: string;
    isDefault?: boolean;
    addressDetail: string;
};

type AddressEditInstance

type AddressEditInstance = ComponentPublicInstance<
    AddressEditProps,
    AddressEditExpose
>;

type AddressEditProps

type AddressEditProps = ExtractPropTypes<typeof addressEditProps>;

type AddressEditSearchItem

type AddressEditSearchItem = {
    name?: string;
    address?: string;
};

type AddressEditThemeVars

type AddressEditThemeVars = {
    addressEditPadding?: string;
    addressEditButtonsPadding?: string;
    addressEditButtonMarginBottom?: string;
    addressEditButtonFontSize?: string;
};

type AddressListAddress

type AddressListAddress = {
    id: Numeric;
    tel: Numeric;
    name: string;
    address: string;
    isDefault?: boolean;
};

type AddressListProps

type AddressListProps = ExtractPropTypes<typeof addressListProps>;

type AddressListThemeVars

type AddressListThemeVars = {
    addressListPadding?: string;
    addressListDisabledTextColor?: string;
    addressListDisabledTextPadding?: string;
    addressListDisabledTextFontSize?: string;
    addressListDisabledTextLineHeight?: number | string;
    addressListAddButtonZIndex?: number | string;
    addressListItemPadding?: string;
    addressListItemTextColor?: string;
    addressListItemDisabledTextColor?: string;
    addressListItemFontSize?: string;
    addressListItemLineHeight?: number | string;
    addressListRadioColor?: string;
    addressListEditIconSize?: string;
};

type AreaInstance

type AreaInstance = ComponentPublicInstance<AreaProps, PickerExpose>;

type AreaList

type AreaList = {
    city_list: Record<string, string>;
    county_list: Record<string, string>;
    province_list: Record<string, string>;
};

type AreaProps

type AreaProps = ExtractPropTypes<typeof areaProps>;

type BackTopProps

type BackTopProps = ExtractPropTypes<typeof backTopProps>;

type BackTopThemeVars

type BackTopThemeVars = {
    backTopSize?: string;
    backTopRight?: string;
    backTopBottom?: string;
    backTopZIndex?: number | string;
    backTopIconSize?: string;
    backTopTextColor?: string;
    backTopBackground?: string;
};

type BadgePosition

type BadgePosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';

type BadgeProps

type BadgeProps = ExtractPropTypes<typeof badgeProps>;

type BadgeThemeVars

type BadgeThemeVars = {
    badgeSize?: string;
    badgeColor?: string;
    badgePadding?: string;
    badgeFontSize?: string;
    badgeFontWeight?: string;
    badgeBorderWidth?: string;
    badgeBackground?: string;
    badgeDotColor?: string;
    badgeDotSize?: string;
    badgeFont?: string;
};

type BarrageInstance

type BarrageInstance = ComponentPublicInstance<BarrageProps, BarrageExpose>;

type BarrageProps

type BarrageProps = ExtractPropTypes<typeof barrageProps>;

type BarrageThemeVars

type BarrageThemeVars = {
    barrageFontSize?: string;
    barrageSpace?: string;
    barrageFont?: string;
    barrageColor?: string;
};

type ButtonIconPosition

type ButtonIconPosition = 'left' | 'right';

type ButtonNativeType

type ButtonNativeType = NonNullable<ButtonHTMLAttributes['type']>;

type ButtonProps

type ButtonProps = ExtractPropTypes<typeof buttonProps>;

type ButtonSize

type ButtonSize = 'large' | 'normal' | 'small' | 'mini';

type ButtonThemeVars

type ButtonThemeVars = {
    buttonMiniHeight?: string;
    buttonMiniPadding?: string;
    buttonMiniFontSize?: string;
    buttonSmallHeight?: string;
    buttonSmallPadding?: string;
    buttonSmallFontSize?: string;
    buttonNormalPadding?: string;
    buttonNormalFontSize?: string;
    buttonLargeHeight?: string;
    buttonDefaultHeight?: string;
    buttonDefaultLineHeight?: number | string;
    buttonDefaultFontSize?: string;
    buttonDefaultColor?: string;
    buttonDefaultBackground?: string;
    buttonDefaultBorderColor?: string;
    buttonPrimaryColor?: string;
    buttonPrimaryBackground?: string;
    buttonPrimaryBorderColor?: string;
    buttonSuccessColor?: string;
    buttonSuccessBackground?: string;
    buttonSuccessBorderColor?: string;
    buttonDangerColor?: string;
    buttonDangerBackground?: string;
    buttonDangerBorderColor?: string;
    buttonWarningColor?: string;
    buttonWarningBackground?: string;
    buttonWarningBorderColor?: string;
    buttonBorderWidth?: string;
    buttonRadius?: string;
    buttonRoundRadius?: string;
    buttonPlainBackground?: string;
    buttonDisabledOpacity?: number | string;
    buttonIconSize?: string;
    buttonLoadingIconSize?: string;
};

type ButtonType

type ButtonType = 'default' | 'primary' | 'success' | 'warning' | 'danger';

type CalendarDayItem

type CalendarDayItem = {
    date?: Date;
    text?: Numeric;
    type?: CalendarDayType;
    topInfo?: string;
    className?: unknown;
    bottomInfo?: string;
};

type CalendarDayType

type CalendarDayType =
    | ''
    | 'start'
    | 'start-end'
    | 'middle'
    | 'end'
    | 'selected'
    | 'multiple-middle'
    | 'multiple-selected'
    | 'disabled'
    | 'placeholder';

type CalendarInstance

type CalendarInstance = ComponentPublicInstance<CalendarProps, CalendarExpose>;

type CalendarProps

type CalendarProps = ExtractPropTypes<typeof calendarProps>;

type CalendarThemeVars

type CalendarThemeVars = {
    calendarBackground?: string;
    calendarPopupHeight?: string;
    calendarHeaderShadow?: string;
    calendarHeaderTitleHeight?: string;
    calendarHeaderTitleFontSize?: string;
    calendarHeaderSubtitleFontSize?: string;
    calendarHeaderActionWidth?: string;
    calendarHeaderActionColor?: string;
    calendarHeaderActionDisabledColor?: string;
    calendarWeekdaysHeight?: string;
    calendarWeekdaysFontSize?: string;
    calendarMonthTitleFontSize?: string;
    calendarMonthMarkColor?: string;
    calendarMonthMarkFontSize?: string;
    calendarDayHeight?: string;
    calendarDayFontSize?: string;
    calendarDayMarginBottom?: string;
    calendarDayDisabledColor?: string;
    calendarRangeEdgeColor?: string;
    calendarRangeEdgeBackground?: string;
    calendarRangeMiddleColor?: string;
    calendarRangeMiddleBackgroundOpacity?: number | string;
    calendarSelectedDaySize?: string;
    calendarSelectedDayColor?: string;
    calendarSelectedDayBackground?: string;
    calendarInfoFontSize?: string;
    calendarInfoLineHeight?: number | string;
    calendarConfirmButtonHeight?: string;
    calendarConfirmButtonMargin?: string;
};

type CalendarType

type CalendarType = 'single' | 'range' | 'multiple';

type CardProps

type CardProps = ExtractPropTypes<typeof cardProps>;

type CardThemeVars

type CardThemeVars = {
    cardPadding?: string;
    cardFontSize?: string;
    cardTextColor?: string;
    cardBackground?: string;
    cardThumbSize?: string;
    cardThumbRadius?: string;
    cardTitleLineHeight?: number | string;
    cardDescColor?: string;
    cardDescLineHeight?: number | string;
    cardPriceColor?: string;
    cardOriginPriceColor?: string;
    cardNumColor?: string;
    cardOriginPriceFontSize?: string;
    cardPriceFontSize?: string;
    cardPriceIntegerFontSize?: string;
    cardPriceFont?: string;
};

type CascaderFieldNames

type CascaderFieldNames = {
    text?: string;
    value?: string;
    children?: string;
};

type CascaderOption

type CascaderOption = {
    text?: string;
    value?: Numeric;
    color?: string;
    disabled?: boolean;
    children?: CascaderOption[];
    className?: unknown;
    [key: PropertyKey]: any;
};

type CascaderProps

type CascaderProps = ExtractPropTypes<typeof cascaderProps>;

type CascaderThemeVars

type CascaderThemeVars = {
    cascaderHeaderHeight?: string;
    cascaderHeaderPadding?: string;
    cascaderTitleFontSize?: string;
    cascaderTitleLineHeight?: number | string;
    cascaderCloseIconSize?: string;
    cascaderCloseIconColor?: string;
    cascaderSelectedIconSize?: string;
    cascaderTabsHeight?: string;
    cascaderActiveColor?: string;
    cascaderOptionsHeight?: string;
    cascaderOptionDisabledColor?: string;
    cascaderTabColor?: string;
    cascaderUnselectedTabColor?: string;
};

type CellArrowDirection

type CellArrowDirection = 'up' | 'down' | 'left' | 'right';

type CellGroupProps

type CellGroupProps = ExtractPropTypes<typeof cellGroupProps>;

type CellGroupThemeVars

type CellGroupThemeVars = {
    cellGroupBackground?: string;
    cellGroupTitleColor?: string;
    cellGroupTitlePadding?: string;
    cellGroupTitleFontSize?: string;
    cellGroupTitleLineHeight?: number | string;
    cellGroupInsetPadding?: string;
    cellGroupInsetRadius?: string;
    cellGroupInsetTitlePadding?: string;
};

type CellProps

type CellProps = ExtractPropTypes<typeof cellProps>;

type CellSize

type CellSize = 'normal' | 'large';

type CellThemeVars

type CellThemeVars = {
    cellFontSize?: string;
    cellLineHeight?: number | string;
    cellVerticalPadding?: string;
    cellHorizontalPadding?: string;
    cellTextColor?: string;
    cellBackground?: string;
    cellBorderColor?: string;
    cellActiveColor?: string;
    cellRequiredColor?: string;
    cellLabelColor?: string;
    cellLabelFontSize?: string;
    cellLabelLineHeight?: number | string;
    cellLabelMarginTop?: string;
    cellValueColor?: string;
    cellIconSize?: string;
    cellRightIconColor?: string;
    cellLargeVerticalPadding?: string;
    cellLargeTitleFontSize?: string;
    cellLargeLabelFontSize?: string;
};

type CheckboxGroupDirection

type CheckboxGroupDirection = CheckerDirection;

type CheckboxGroupInstance

type CheckboxGroupInstance = ComponentPublicInstance<
    CheckboxGroupProps,
    CheckboxGroupExpose
>;

type CheckboxGroupProps

type CheckboxGroupProps = ExtractPropTypes<typeof checkboxGroupProps>;

type CheckboxGroupToggleAllOptions

type CheckboxGroupToggleAllOptions =
    | boolean
    | {
          checked?: boolean;
          skipDisabled?: boolean;
      };

type CheckboxInstance

type CheckboxInstance = ComponentPublicInstance<CheckboxProps, CheckboxExpose>;

type CheckboxLabelPosition

type CheckboxLabelPosition = CheckerLabelPosition;

type CheckboxProps

type CheckboxProps = ExtractPropTypes<typeof checkboxProps>;

type CheckboxShape

type CheckboxShape = CheckerShape;

type CheckboxThemeVars

type CheckboxThemeVars = {
    checkboxSize?: string;
    checkboxBorderColor?: string;
    checkboxDuration?: string;
    checkboxLabelMargin?: string;
    checkboxLabelColor?: string;
    checkboxCheckedIconColor?: string;
    checkboxDisabledIconColor?: string;
    checkboxDisabledLabelColor?: string;
    checkboxDisabledBackground?: string;
};

type CircleProps

type CircleProps = ExtractPropTypes<typeof circleProps>;

type CircleStartPosition

type CircleStartPosition = 'top' | 'right' | 'bottom' | 'left';

type CircleThemeVars

type CircleThemeVars = {
    circleSize?: string;
    circleColor?: string;
    circleLayerColor?: string;
    circleTextColor?: string;
    circleTextFontWeight?: string;
    circleTextFontSize?: string;
    circleTextLineHeight?: number | string;
};

type CollapseInstance

type CollapseInstance = ComponentPublicInstance<{
    toggleAll: (options?: boolean | CollapseToggleAllOptions) => void;
}>;

type CollapseItemInstance

type CollapseItemInstance = ComponentPublicInstance<
    CollapseItemProps,
    CollapseItemExpose
>;

type CollapseItemProps

type CollapseItemProps = ExtractPropTypes<typeof collapseItemProps>;

type CollapseItemThemeVars

type CollapseItemThemeVars = {
    collapseItemDuration?: string;
    collapseItemContentPadding?: string;
    collapseItemContentFontSize?: string;
    collapseItemContentLineHeight?: number | string;
    collapseItemContentTextColor?: string;
    collapseItemContentBackground?: string;
    collapseItemTitleDisabledColor?: string;
};

type CollapseProps

type CollapseProps = ExtractPropTypes<typeof collapseProps>;

type CollapseToggleAllOptions

type CollapseToggleAllOptions =
    | boolean
    | {
          expanded?: boolean;
          skipDisabled?: boolean;
      };

type ColProps

type ColProps = ExtractPropTypes<typeof colProps>;

type ConfigProviderProps

type ConfigProviderProps = ExtractPropTypes<typeof configProviderProps>;

type ConfigProviderTheme

type ConfigProviderTheme = 'light' | 'dark';

type ConfigProviderThemeVars

type ConfigProviderThemeVars = BaseThemeVars &
    import('../action-bar').ActionBarThemeVars &
    import('../action-bar-button').ActionBarButtonThemeVars &
    import('../action-bar-icon').ActionBarIconThemeVars &
    import('../action-sheet').ActionSheetThemeVars &
    import('../address-edit').AddressEditThemeVars &
    import('../address-list').AddressListThemeVars &
    import('../back-top').BackTopThemeVars &
    import('../badge').BadgeThemeVars &
    import('../barrage').BarrageThemeVars &
    import('../button').ButtonThemeVars &
    import('../calendar').CalendarThemeVars &
    import('../card').CardThemeVars &
    import('../cascader').CascaderThemeVars &
    import('../cell').CellThemeVars &
    import('../cell-group').CellGroupThemeVars &
    import('../checkbox').CheckboxThemeVars &
    import('../circle').CircleThemeVars &
    import('../collapse-item').CollapseItemThemeVars &
    import('../contact-card').ContactCardThemeVars &
    import('../contact-edit').ContactEditThemeVars &
    import('../contact-list').ContactListThemeVars &
    import('../count-down').CountDownThemeVars &
    import('../coupon').CouponThemeVars &
    import('../coupon-cell').CouponCellThemeVars &
    import('../coupon-list').CouponListThemeVars &
    import('../dialog').DialogThemeVars &
    import('../divider').DividerThemeVars &
    import('../dropdown-item').DropdownItemThemeVars &
    import('../dropdown-menu').DropdownMenuThemeVars &
    import('../empty').EmptyThemeVars &
    import('../highlight').HighlightThemeVars &
    import('../field').FieldThemeVars &
    import('../floating-bubble').FloatingBubbleThemeVars &
    import('../floating-panel').FloatingPanelThemeVars &
    import('../grid-item').GridItemThemeVars &
    import('../image').ImageThemeVars &
    import('../image-preview').ImagePreviewThemeVars &
    import('../index-anchor').IndexAnchorThemeVars &
    import('../index-bar').IndexBarThemeVars &
    import('../list').ListThemeVars &
    import('../loading').LoadingThemeVars &
    import('../nav-bar').NavBarThemeVars &
    import('../notice-bar').NoticeBarThemeVars &
    import('../notify').NotifyThemeVars &
    import('../number-keyboard').NumberKeyboardThemeVars &
    import('../overlay').OverlayThemeVars &
    import('../pagination').PaginationThemeVars &
    import('../password-input').PasswordInputThemeVars &
    import('../picker').PickerThemeVars &
    import('../picker-group').PickerGroupThemeVars &
    import('../popover').PopoverThemeVars &
    import('../popup').PopupThemeVars &
    import('../progress').ProgressThemeVars &
    import('../pull-refresh').PullRefreshThemeVars &
    import('../radio').RadioThemeVars &
    import('../rate').RateThemeVars &
    import('../rolling-text').RollingTextThemeVars &
    import('../search').SearchThemeVars &
    import('../share-sheet').ShareSheetThemeVars &
    import('../sidebar').SidebarThemeVars &
    import('../sidebar-item').SidebarItemThemeVars &
    import('../signature').SignatureThemeVars &
    import('../skeleton').SkeletonThemeVars &
    import('../slider').SliderThemeVars &
    import('../step').StepThemeVars &
    import('../stepper').StepperThemeVars &
    import('../steps').StepsThemeVars &
    import('../sticky').StickyThemeVars &
    import('../submit-bar').SubmitBarThemeVars &
    import('../swipe').SwipeThemeVars &
    import('../switch').SwitchThemeVars &
    import('../tabbar').TabbarThemeVars &
    import('../tabbar-item').TabbarItemThemeVars &
    import('../tabs').TabsThemeVars &
    import('../tag').TagThemeVars &
    import('../toast').ToastThemeVars &
    import('../tree-select').TreeSelectThemeVars &
    import('../uploader').UploaderThemeVars &
    import('../watermark').WatermarkThemeVars;

type ConfigProviderThemeVarsScope

type ConfigProviderThemeVarsScope = 'local' | 'global';

type ContactCardProps

type ContactCardProps = ExtractPropTypes<typeof contactCardProps>;

type ContactCardThemeVars

type ContactCardThemeVars = {
    contactCardPadding?: string;
    contactCardAddIconSize?: string;
    contactCardAddIconColor?: string;
    contactCardTitleLineHeight?: number | string;
};

type ContactCardType

type ContactCardType = 'add' | 'edit';

type ContactEditInfo

type ContactEditInfo = {
    tel: string;
    name: string;
    isDefault?: boolean;
};

type ContactEditProps

type ContactEditProps = ExtractPropTypes<typeof contactEditProps>;

type ContactEditThemeVars

type ContactEditThemeVars = {
    contactEditPadding?: string;
    contactEditFieldsRadius?: string;
    contactEditButtonsPadding?: string;
    contactEditButtonMarginBottom?: string;
    contactEditButtonFontSize?: string;
    contactEditFieldLabelWidth?: string;
};

type ContactListItem

type ContactListItem = {
    id?: Numeric;
    tel: Numeric;
    name: string;
    isDefault?: boolean;
};

type ContactListProps

type ContactListProps = ExtractPropTypes<typeof contactListProps>;

type ContactListThemeVars

type ContactListThemeVars = {
    contactListEditIconSize?: string;
    contactListAddButtonZIndex?: number | string;
    contactListRadioColor?: string;
    contactListItemPadding?: string;
};

type CountDownCurrentTime

type CountDownCurrentTime = CurrentTime;

type CountDownInstance

type CountDownInstance = ComponentPublicInstance<CountDownProps, CountDownExpose>;

type CountDownProps

type CountDownProps = ExtractPropTypes<typeof countDownProps>;

type CountDownThemeVars

type CountDownThemeVars = {
    countDownTextColor?: string;
    countDownFontSize?: string;
    countDownLineHeight?: number | string;
};

type CouponCellProps

type CouponCellProps = ExtractPropTypes<typeof couponCellProps>;

type CouponCellThemeVars

type CouponCellThemeVars = {
    couponCellSelectedTextColor?: string;
};

type CouponInfo

type CouponInfo = {
    id: Numeric;
    name: string;
    endAt: number;
    value: number;
    startAt: number;
    reason?: string;
    discount?: number;
    unitDesc?: string;
    condition?: string;
    valueDesc?: string;
    description: string;
    denominations?: number;
    originCondition?: number;
};

type CouponListProps

type CouponListProps = ExtractPropTypes<typeof couponListProps>;

type CouponListThemeVars

type CouponListThemeVars = {
    couponListBackground?: string;
    couponListFieldPadding?: string;
    couponListExchangeButtonHeight?: string;
    couponListCloseButtonHeight?: string;
    couponListEmptyTipColor?: string;
    couponListEmptyTipFontSize?: string;
    couponListEmptyTipLineHeight?: number | string;
};

type CouponThemeVars

type CouponThemeVars = {
    couponMargin?: string;
    couponContentHeight?: string;
    couponContentPadding?: string;
    couponContentTextColor?: string;
    couponBackground?: string;
    couponActiveBackground?: string;
    couponRadius?: string;
    couponShadow?: string;
    couponHeadWidth?: string;
    couponAmountColor?: string;
    couponAmountFontSize?: string;
    couponCurrencyFontSize?: string;
    couponNameFontSize?: string;
    couponDisabledTextColor?: string;
    couponDescriptionPadding?: string;
    couponDescriptionBorderColor?: string;
    couponCheckboxColor?: string;
};

type DatePickerColumnType

type DatePickerColumnType = 'year' | 'month' | 'day';

type DatePickerInstance

type DatePickerInstance = ComponentPublicInstance<DatePickerProps, DatePickerExpose>;

type DatePickerProps

type DatePickerProps = ExtractPropTypes<typeof datePickerProps>;

type DialogMessage

type DialogMessage = string | (() => JSX.Element);

type DialogMessageAlign

type DialogMessageAlign = 'left' | 'center' | 'right' | 'justify';

type DialogOptions

type DialogOptions = {
    title?: string;
    width?: Numeric;
    theme?: DialogTheme;
    message?: DialogMessage;
    overlay?: boolean;
    teleport?: TeleportProps['to'];
    className?: unknown;
    allowHtml?: boolean;
    lockScroll?: boolean;
    transition?: string;
    beforeClose?: Interceptor;
    messageAlign?: DialogMessageAlign;
    overlayClass?: string;
    overlayStyle?: CSSProperties;
    closeOnPopstate?: boolean;
    showCancelButton?: boolean;
    showConfirmButton?: boolean;
    cancelButtonText?: string;
    cancelButtonColor?: string;
    cancelButtonDisabled?: boolean;
    confirmButtonText?: string;
    confirmButtonColor?: string;
    confirmButtonDisabled?: boolean;
    closeOnClickOverlay?: boolean;
    destroyOnClose?: boolean;
    keyboardEnabled?: boolean;
};

type DialogProps

type DialogProps = ExtractPropTypes<typeof dialogProps>;

type DialogTheme

type DialogTheme = 'default' | 'round-button';

type DialogThemeVars

type DialogThemeVars = {
    dialogWidth?: string;
    dialogSmallScreenWidth?: string;
    dialogFontSize?: string;
    dialogTransition?: string;
    dialogRadius?: string;
    dialogBackground?: string;
    dialogHeaderFontWeight?: string;
    dialogHeaderLineHeight?: number | string;
    dialogHeaderPaddingTop?: string;
    dialogHeaderIsolatedPadding?: string;
    dialogMessagePadding?: string;
    dialogMessageFontSize?: string;
    dialogMessageLineHeight?: number | string;
    dialogMessageMaxHeight?: string;
    dialogHasTitleMessageTextColor?: string;
    dialogHasTitleMessagePaddingTop?: string;
    dialogButtonHeight?: string;
    dialogRoundButtonHeight?: string;
    dialogConfirmButtonTextColor?: string;
};

type DividerContentPosition

type DividerContentPosition = 'left' | 'center' | 'right';

type DividerProps

type DividerProps = ExtractPropTypes<typeof dividerProps>;

type DividerThemeVars

type DividerThemeVars = {
    dividerMargin?: string;
    dividerTextColor?: string;
    dividerFontSize?: string;
    dividerLineHeight?: number | string;
    dividerBorderColor?: string;
    dividerContentPadding?: string;
    dividerContentLeftWidth?: string;
    dividerContentRightWidth?: string;
};

type DropdownItemInstance

type DropdownItemInstance = ComponentPublicInstance<
    DropdownItemProps,
    DropdownItemExpose
>;

type DropdownItemOption

type DropdownItemOption = {
    disabled?: boolean;
    text: string;
    icon?: string;
    value: DropdownItemOptionValue;
};

type DropdownItemProps

type DropdownItemProps = ExtractPropTypes<typeof dropdownItemProps>;

type DropdownItemThemeVars

type DropdownItemThemeVars = {
    dropdownItemZIndex?: number | string;
};

type DropdownMenuDirection

type DropdownMenuDirection = 'up' | 'down';

type DropdownMenuInstance

type DropdownMenuInstance = ComponentPublicInstance<
    DropdownMenuProps,
    DropdownMenuExpose
>;

type DropdownMenuProps

type DropdownMenuProps = ExtractPropTypes<typeof dropdownMenuProps>;

type DropdownMenuThemeVars

type DropdownMenuThemeVars = {
    dropdownMenuHeight?: string;
    dropdownMenuBackground?: string;
    dropdownMenuShadow?: string;
    dropdownMenuTitleFontSize?: string;
    dropdownMenuTitleTextColor?: string;
    dropdownMenuTitleActiveTextColor?: string;
    dropdownMenuTitleDisabledTextColor?: string;
    dropdownMenuTitlePadding?: string;
    dropdownMenuTitleLineHeight?: number | string;
    dropdownMenuOptionActiveColor?: string;
    dropdownMenuOptionDisabledColor?: string;
    dropdownMenuContentMaxHeight?: string;
};

type EmptyProps

type EmptyProps = ExtractPropTypes<typeof emptyProps>;

type EmptyThemeVars

type EmptyThemeVars = {
    emptyPadding?: string;
    emptyImageSize?: string;
    emptyDescriptionMarginTop?: string;
    emptyDescriptionPadding?: string;
    emptyDescriptionColor?: string;
    emptyDescriptionFontSize?: string;
    emptyDescriptionLineHeight?: number | string;
    emptyBottomMarginTop?: string;
};

type FieldAutosizeConfig

type FieldAutosizeConfig = {
    maxHeight?: number;
    minHeight?: number;
};

type FieldClearTrigger

type FieldClearTrigger = 'always' | 'focus';

type FieldFormatTrigger

type FieldFormatTrigger = 'onBlur' | 'onChange';

type FieldInstance

type FieldInstance = ComponentPublicInstance<FieldProps, FieldExpose>;

type FieldProps

type FieldProps = ExtractPropTypes<typeof fieldProps>;

type FieldRule

type FieldRule = {
    pattern?: RegExp;
    trigger?: FieldValidateTrigger | FieldValidateTrigger[];
    message?: FieldRuleMessage;
    required?: boolean;
    validator?: FieldRuleValidator;
    formatter?: FieldRuleFormatter;
    validateEmpty?: boolean;
};

type FieldRuleFormatter

type FieldRuleFormatter = (value: any, rule: FieldRule) => string;

type FieldRuleMessage

type FieldRuleMessage = string | ((value: any, rule: FieldRule) => string);

type FieldRuleValidator

type FieldRuleValidator = (
    value: any,
    rule: FieldRule
) => boolean | string | Promise<boolean | string>;

type FieldTextAlign

type FieldTextAlign = 'left' | 'center' | 'right' | 'top';

type FieldThemeVars

type FieldThemeVars = {
    fieldLabelWidth?: string;
    fieldLabelColor?: string;
    fieldLabelMarginRight?: string;
    fieldInputTextColor?: string;
    fieldInputErrorTextColor?: string;
    fieldInputDisabledTextColor?: string;
    fieldPlaceholderTextColor?: string;
    fieldIconSize?: string;
    fieldClearIconSize?: string;
    fieldClearIconColor?: string;
    fieldRightIconColor?: string;
    fieldErrorMessageColor?: string;
    fieldErrorMessageFontSize?: string;
    fieldTextAreaMinHeight?: string;
    fieldWordLimitColor?: string;
    fieldWordLimitFontSize?: string;
    fieldWordLimitLineHeight?: number | string;
    fieldDisabledTextColor?: string;
    fieldRequiredMarkColor?: string;
};

type FieldType

type FieldType =
    | 'tel'
    | 'url'
    | 'date'
    | 'file'
    | 'text'
    | 'time'
    | 'week'
    | 'color'
    | 'digit'
    | 'email'
    | 'image'
    | 'month'
    | 'radio'
    | 'range'
    | 'reset'
    | 'button'
    | 'hidden'
    | 'number'
    | 'search'
    | 'submit'
    | 'checkbox'
    | 'password'
    | 'textarea'
    | 'datetime-local';

type FieldValidateError

type FieldValidateError = {
    name?: string;
    message: string;
};

type FieldValidateTrigger

type FieldValidateTrigger = 'onBlur' | 'onChange' | 'onSubmit';

type FieldValidationStatus

type FieldValidationStatus = 'passed' | 'failed' | 'unvalidated';

type FloatingBubbleAxis

type FloatingBubbleAxis = 'x' | 'y' | 'xy' | 'lock';

type FloatingBubbleMagnetic

type FloatingBubbleMagnetic = 'x' | 'y';

type FloatingBubbleOffset

type FloatingBubbleOffset = {
    x: number;
    y: number;
};

type FloatingBubbleProps

type FloatingBubbleProps = ExtractPropTypes<typeof floatingBubbleProps>;

type FloatingBubbleThemeVars

type FloatingBubbleThemeVars = {
    floatingBubbleSize?: string;
    floatingBubbleInitialGap?: string;
    floatingBubbleIconSize?: string;
    floatingBubbleBackground?: string;
    floatingBubbleColor?: string;
    floatingBubbleZIndex?: number | string;
};

type FloatingPanelProps

type FloatingPanelProps = ExtractPropTypes<typeof floatingPanelProps>;

type FloatingPanelThemeVars

type FloatingPanelThemeVars = {
    floatingPanelBorderRadius?: string;
    floatingPanelHeaderHeight?: string;
    floatingPanelZIndex?: number | string;
    floatingPanelBackground?: string;
    floatingPanelBarWidth?: string;
    floatingPanelBarHeight?: string;
    floatingPanelBarColor?: string;
};

type FormInstance

type FormInstance = ComponentPublicInstance<FormProps, FormExpose>;

type FormProps

type FormProps = ExtractPropTypes<typeof formProps>;

type GridDirection

type GridDirection = 'horizontal' | 'vertical';

type GridItemProps

type GridItemProps = ExtractPropTypes<typeof gridItemProps>;

type GridItemThemeVars

type GridItemThemeVars = {
    gridItemContentPadding?: string;
    gridItemContentBackground?: string;
    gridItemContentActiveColor?: string;
    gridItemIconSize?: string;
    gridItemTextColor?: string;
    gridItemTextFontSize?: string;
};

type GridProps

type GridProps = ExtractPropTypes<typeof gridProps>;

type HighlightProps

type HighlightProps = ExtractPropTypes<typeof highlightProps>;

type HighlightThemeVars

type HighlightThemeVars = {
    highlightTagColor?: string;
};

type IconProps

type IconProps = ExtractPropTypes<typeof iconProps>;

type ImageFit

type ImageFit = CSSProperties['objectFit'];

type ImagePosition

type ImagePosition = CSSProperties['objectPosition'];

type ImagePreviewInstance

type ImagePreviewInstance = ComponentPublicInstance<
    ImagePreviewProps,
    ImagePreviewExpose
>;

type ImagePreviewOptions

type ImagePreviewOptions = {
    loop?: boolean;
    images: string[];
    maxZoom?: number;
    minZoom?: number;
    vertical?: boolean;
    teleport?: TeleportProps['to'];
    className?: unknown;
    showIndex?: boolean;
    closeable?: boolean;
    closeIcon?: string;
    transition?: string;
    beforeClose?: Interceptor;
    doubleScale?: boolean;
    overlayStyle?: CSSProperties;
    overlayClass?: unknown;
    swipeDuration?: number;
    startPosition?: number;
    showIndicators?: boolean;
    closeOnPopstate?: boolean;
    closeIconPosition?: PopupCloseIconPosition;
    closeOnClickImage?: boolean;
    closeOnClickOverlay?: boolean;
    onClose?(): void;
    onScale?(args: { scale: number; index: number }): void;
    onChange?(index: number): void;
};

type ImagePreviewProps

type ImagePreviewProps = ExtractPropTypes<typeof imagePreviewProps>;

type ImagePreviewScaleEventParams

type ImagePreviewScaleEventParams = {
    scale: number;
    index: number;
};

type ImagePreviewThemeVars

type ImagePreviewThemeVars = {
    imagePreviewIndexTextColor?: string;
    imagePreviewIndexFontSize?: string;
    imagePreviewIndexLineHeight?: number | string;
    imagePreviewIndexTextShadow?: string;
    imagePreviewOverlayBackground?: string;
    imagePreviewCloseIconSize?: string;
    imagePreviewCloseIconColor?: string;
    imagePreviewCloseIconMargin?: string;
    imagePreviewCloseIconZIndex?: number | string;
};

type ImageProps

type ImageProps = ExtractPropTypes<typeof imageProps>;

type ImageThemeVars

type ImageThemeVars = {
    imagePlaceholderTextColor?: string;
    imagePlaceholderFontSize?: string;
    imagePlaceholderBackground?: string;
    imageLoadingIconSize?: string;
    imageLoadingIconColor?: string;
    imageErrorIconSize?: string;
    imageErrorIconColor?: string;
};

type IndexAnchorProps

type IndexAnchorProps = ExtractPropTypes<typeof indexAnchorProps>;

type IndexAnchorThemeVars

type IndexAnchorThemeVars = {
    indexAnchorZIndex?: number | string;
    indexAnchorPadding?: string;
    indexAnchorTextColor?: string;
    indexAnchorFontWeight?: string;
    indexAnchorFontSize?: string;
    indexAnchorLineHeight?: number | string;
    indexAnchorBackground?: string;
    indexAnchorStickyTextColor?: string;
    indexAnchorStickyBackground?: string;
};

type IndexBarInstance

type IndexBarInstance = ComponentPublicInstance<IndexBarProps, IndexBarExpose>;

type IndexBarProps

type IndexBarProps = ExtractPropTypes<typeof indexBarProps>;

type IndexBarThemeVars

type IndexBarThemeVars = {
    indexBarSidebarZIndex?: number | string;
    indexBarIndexFontSize?: string;
    indexBarIndexLineHeight?: number | string;
    indexBarIndexActiveColor?: string;
};

type ListDirection

type ListDirection = 'up' | 'down';

type ListInstance

type ListInstance = ComponentPublicInstance<ListProps, ListExpose>;

type ListProps

type ListProps = ExtractPropTypes<typeof listProps>;

type ListThemeVars

type ListThemeVars = {
    listTextColor?: string;
    listTextFontSize?: string;
    listTextLineHeight?: number | string;
    listLoadingIconSize?: string;
};

type LoadingProps

type LoadingProps = ExtractPropTypes<typeof loadingProps>;

type LoadingThemeVars

type LoadingThemeVars = {
    loadingTextColor?: string;
    loadingTextFontSize?: string;
    loadingSpinnerColor?: string;
    loadingSpinnerSize?: string;
    loadingSpinnerDuration?: string;
};

type LoadingType

type LoadingType = 'circular' | 'spinner';

type NavBarProps

type NavBarProps = ExtractPropTypes<typeof navBarProps>;

type NavBarThemeVars

type NavBarThemeVars = {
    navBarHeight?: string;
    navBarBackground?: string;
    navBarArrowSize?: string;
    navBarIconColor?: string;
    navBarTextColor?: string;
    navBarTitleFontSize?: string;
    navBarTitleTextColor?: string;
    navBarZIndex?: number | string;
};

type NoticeBarInstance

type NoticeBarInstance = ComponentPublicInstance<NoticeBarProps, NoticeBarExpose>;

type NoticeBarMode

type NoticeBarMode = 'closeable' | 'link';

type NoticeBarProps

type NoticeBarProps = ExtractPropTypes<typeof noticeBarProps>;

type NoticeBarThemeVars

type NoticeBarThemeVars = {
    noticeBarHeight?: string;
    noticeBarPadding?: string;
    noticeBarWrapablePadding?: string;
    noticeBarTextColor?: string;
    noticeBarFontSize?: string;
    noticeBarLineHeight?: number | string;
    noticeBarBackground?: string;
    noticeBarIconSize?: string;
    noticeBarIconMinWidth?: string;
};

type NotifyOptions

type NotifyOptions = {
    type?: NotifyType;
    color?: string;
    message?: NotifyMessage;
    duration?: number;
    zIndex?: number;
    position?: NotifyPosition;
    className?: unknown;
    background?: string;
    lockScroll?: boolean;
    teleport?: TeleportProps['to'];
    onClick?: (event: MouseEvent) => void;
    onClose?: () => void;
    onOpened?: () => void;
};

type NotifyProps

type NotifyProps = ExtractPropTypes<typeof notifyProps>;

type NotifyThemeVars

type NotifyThemeVars = {
    notifyTextColor?: string;
    notifyPadding?: string;
    notifyFontSize?: string;
    notifyLineHeight?: number | string;
    notifyPrimaryBackground?: string;
    notifySuccessBackground?: string;
    notifyDangerBackground?: string;
    notifyWarningBackground?: string;
};

type NotifyType

type NotifyType = 'primary' | 'success' | 'danger' | 'warning';

type NumberKeyboardProps

type NumberKeyboardProps = ExtractPropTypes<typeof numberKeyboardProps>;

type NumberKeyboardTheme

type NumberKeyboardTheme = 'default' | 'custom';

type NumberKeyboardThemeVars

type NumberKeyboardThemeVars = {
    numberKeyboardBackground?: string;
    numberKeyboardKeyHeight?: string;
    numberKeyboardKeyFontSize?: string;
    numberKeyboardKeyActiveColor?: string;
    numberKeyboardKeyBackground?: string;
    numberKeyboardDeleteFontSize?: string;
    numberKeyboardTitleColor?: string;
    numberKeyboardTitleHeight?: string;
    numberKeyboardTitleFontSize?: string;
    numberKeyboardClosePadding?: string;
    numberKeyboardCloseColor?: string;
    numberKeyboardCloseFontSize?: string;
    numberKeyboardButtonTextColor?: string;
    numberKeyboardButtonBackground?: string;
    numberKeyboardZIndex?: number | string;
};

type OverlayProps

type OverlayProps = ExtractPropTypes<typeof overlayProps>;

type OverlayThemeVars

type OverlayThemeVars = {
    overlayZIndex?: number | string;
    overlayBackground?: string;
};

type PaginationMode

type PaginationMode = 'simple' | 'multi';

type PaginationProps

type PaginationProps = ExtractPropTypes<typeof paginationProps>;

type PaginationThemeVars

type PaginationThemeVars = {
    paginationHeight?: string;
    paginationFontSize?: string;
    paginationItemWidth?: string;
    paginationItemDefaultColor?: string;
    paginationItemDisabledColor?: string;
    paginationItemDisabledBackground?: string;
    paginationBackground?: string;
    paginationDescColor?: string;
    paginationDisabledOpacity?: number | string;
};

type PasswordInputProps

type PasswordInputProps = ExtractPropTypes<typeof passwordInputProps>;

type PasswordInputThemeVars

type PasswordInputThemeVars = {
    passwordInputHeight?: string;
    passwordInputMargin?: string;
    passwordInputFontSize?: string;
    passwordInputRadius?: string;
    passwordInputBackground?: string;
    passwordInputInfoColor?: string;
    passwordInputInfoFontSize?: string;
    passwordInputErrorInfoColor?: string;
    passwordInputDotSize?: string;
    passwordInputDotColor?: string;
    passwordInputTextColor?: string;
    passwordInputCursorColor?: string;
    passwordInputCursorWidth?: string;
    passwordInputCursorHeight?: string;
    passwordInputCursorDuration?: string;
};

type PickerCancelEventParams

type PickerCancelEventParams = PickerConfirmEventParams;

type PickerChangeEventParams

type PickerChangeEventParams = PickerConfirmEventParams & {
    columnIndex: number;
};

type PickerColumn

type PickerColumn = PickerOption[];

type PickerConfirmEventParams

type PickerConfirmEventParams = {
    selectedValues: Numeric[];
    selectedOptions: Array<PickerOption | undefined>;
    selectedIndexes: number[];
};

type PickerFieldNames

type PickerFieldNames = {
    text?: string;
    value?: string;
    children?: string;
};

type PickerGroupProps

type PickerGroupProps = ExtractPropTypes<typeof pickerGroupProps>;

type PickerGroupThemeVars

type PickerGroupThemeVars = {
    pickerGroupBackground?: string;
};

type PickerInstance

type PickerInstance = ComponentPublicInstance<PickerProps, PickerExpose>;

type PickerOption

type PickerOption = {
    text?: Numeric;
    value?: Numeric;
    disabled?: boolean;
    children?: PickerColumn;
    className?: unknown;
    [key: PropertyKey]: any;
};

type PickerProps

type PickerProps = ExtractPropTypes<typeof pickerProps>;

type PickerThemeVars

type PickerThemeVars = {
    pickerBackground?: string;
    pickerToolbarHeight?: string;
    pickerTitleFontSize?: string;
    pickerTitleLineHeight?: number | string;
    pickerActionPadding?: string;
    pickerActionFontSize?: string;
    pickerConfirmActionColor?: string;
    pickerCancelActionColor?: string;
    pickerOptionFontSize?: string;
    pickerOptionPadding?: string;
    pickerOptionTextColor?: string;
    pickerOptionDisabledOpacity?: number | string;
    pickerLoadingIconColor?: string;
    pickerLoadingMaskColor?: string;
    pickerMaskColor?: string;
};

type PickerToolbarPosition

type PickerToolbarPosition = 'top' | 'bottom';

type PopoverAction

type PopoverAction = {
    text: string;
    icon?: string;
    color?: string;
    disabled?: boolean;
    className?: string;
    [key: PropertyKey]: any;
};

type PopoverPlacement

type PopoverPlacement =
    | 'top'
    | 'top-start'
    | 'top-end'
    | 'left'
    | 'left-start'
    | 'left-end'
    | 'right'
    | 'right-start'
    | 'right-end'
    | 'bottom'
    | 'bottom-start'
    | 'bottom-end';

type PopoverProps

type PopoverProps = ExtractPropTypes<typeof popoverProps>;

type PopoverTheme

type PopoverTheme = 'light' | 'dark';

type PopoverThemeVars

type PopoverThemeVars = {
    popoverArrowSize?: string;
    popoverRadius?: string;
    popoverActionWidth?: string;
    popoverActionHeight?: string;
    popoverActionFontSize?: string;
    popoverActionLineHeight?: number | string;
    popoverActionIconSize?: string;
    popoverLightTextColor?: string;
    popoverLightBackground?: string;
    popoverLightActionDisabledTextColor?: string;
    popoverDarkTextColor?: string;
    popoverDarkBackground?: string;
    popoverDarkActionDisabledTextColor?: string;
};

type PopoverTrigger

type PopoverTrigger = 'manual' | 'click';

type PopupCloseIconPosition

type PopupCloseIconPosition =
    | 'top-left'
    | 'top-right'
    | 'bottom-left'
    | 'bottom-right';

type PopupInstance

type PopupInstance = ComponentPublicInstance<PopupProps, PopupExpose>;

type PopupPosition

type PopupPosition = 'top' | 'left' | 'bottom' | 'right' | 'center' | '';

type PopupProps

type PopupProps = ExtractPropTypes<typeof popupProps>;

type PopupThemeVars

type PopupThemeVars = {
    popupBackground?: string;
    popupTransition?: string;
    popupRoundRadius?: string;
    popupCloseIconSize?: string;
    popupCloseIconColor?: string;
    popupCloseIconMargin?: string;
    popupCloseIconZIndex?: number | string;
};

type ProgressInstance

type ProgressInstance = ComponentPublicInstance<ProgressProps>;

type ProgressProps

type ProgressProps = ExtractPropTypes<typeof progressProps>;

type ProgressThemeVars

type ProgressThemeVars = {
    progressHeight?: string;
    progressColor?: string;
    progressInactiveColor?: string;
    progressBackground?: string;
    progressPivotPadding?: string;
    progressPivotTextColor?: string;
    progressPivotFontSize?: string;
    progressPivotLineHeight?: number | string;
    progressPivotBackground?: string;
};

type PullRefreshProps

type PullRefreshProps = ExtractPropTypes<typeof pullRefreshProps>;

type PullRefreshThemeVars

type PullRefreshThemeVars = {
    pullRefreshHeadHeight?: string;
    pullRefreshHeadFontSize?: string;
    pullRefreshHeadTextColor?: string;
    pullRefreshLoadingIconSize?: string;
};

type RadioGroupDirection

type RadioGroupDirection = CheckerDirection;

type RadioGroupProps

type RadioGroupProps = ExtractPropTypes<typeof radioGroupProps>;

type RadioLabelPosition

type RadioLabelPosition = CheckerLabelPosition;

type RadioProps

type RadioProps = ExtractPropTypes<typeof radioProps>;

type RadioShape

type RadioShape = CheckerShape | 'dot';

type RadioThemeVars

type RadioThemeVars = {
    radioSize?: string;
    radioDotSize?: string;
    radioBorderColor?: string;
    radioDuration?: string;
    radioLabelMargin?: string;
    radioLabelColor?: string;
    radioCheckedIconColor?: string;
    radioDisabledIconColor?: string;
    radioDisabledLabelColor?: string;
    radioDisabledBackground?: string;
};

type RateProps

type RateProps = ExtractPropTypes<typeof rateProps>;

type RateThemeVars

type RateThemeVars = {
    rateIconSize?: string;
    rateIconGutter?: string;
    rateIconVoidColor?: string;
    rateIconFullColor?: string;
    rateIconDisabledColor?: string;
};

type RollingTextDirection

type RollingTextDirection = 'up' | 'down';

type RollingTextInstance

type RollingTextInstance = ComponentPublicInstance<
    RollingTextProps,
    RollingTextExpose
>;

type RollingTextProps

type RollingTextProps = ExtractPropTypes<typeof rollingTextProps>;

type RollingTextStopOrder

type RollingTextStopOrder = 'ltr' | 'rtl';

type RollingTextThemeVars

type RollingTextThemeVars = {
    rollingTextBackground?: string;
    rollingTextColor?: string;
    rollingTextFontSize?: string;
    rollingTextGap?: string;
    rollingTextItemWidth?: string;
    rollingTextItemBorderRadius?: string;
};

type RowAlign

type RowAlign = 'top' | 'center' | 'bottom';

type RowJustify

type RowJustify = 'start' | 'end' | 'center' | 'space-around' | 'space-between';

type RowProps

type RowProps = ExtractPropTypes<typeof rowProps>;

type SearchInstance

type SearchInstance = ComponentPublicInstance<SearchProps, SearchExpose>;

type SearchProps

type SearchProps = ExtractPropTypes<typeof searchProps>;

type SearchShape

type SearchShape = 'square' | 'round';

type SearchThemeVars

type SearchThemeVars = {
    searchPadding?: string;
    searchBackground?: string;
    searchContentBackground?: string;
    searchInputHeight?: string;
    searchLabelPadding?: string;
    searchLabelColor?: string;
    searchLabelFontSize?: string;
    searchLeftIconColor?: string;
    searchActionPadding?: string;
    searchActionTextColor?: string;
    searchActionFontSize?: string;
};

type ShareSheetOption

type ShareSheetOption = {
    name: string;
    icon: string;
    className?: string;
    description?: string;
};

type ShareSheetOptions

type ShareSheetOptions = ShareSheetOption[] | ShareSheetOption[][];

type ShareSheetProps

type ShareSheetProps = ExtractPropTypes<typeof shareSheetProps>;

type ShareSheetThemeVars

type ShareSheetThemeVars = {
    shareSheetHeaderPadding?: string;
    shareSheetTitleColor?: string;
    shareSheetTitleFontSize?: string;
    shareSheetTitleLineHeight?: number | string;
    shareSheetDescriptionColor?: string;
    shareSheetDescriptionFontSize?: string;
    shareSheetDescriptionLineHeight?: number | string;
    shareSheetIconSize?: string;
    shareSheetOptionNameColor?: string;
    shareSheetOptionNameFontSize?: string;
    shareSheetOptionDescriptionColor?: string;
    shareSheetOptionDescriptionFontSize?: string;
    shareSheetCancelButtonFontSize?: string;
    shareSheetCancelButtonHeight?: string;
    shareSheetCancelButtonBackground?: string;
};

type SidebarItemProps

type SidebarItemProps = ExtractPropTypes<typeof sidebarItemProps>;

type SidebarItemThemeVars

type SidebarItemThemeVars = {
    sidebarFontSize?: string;
    sidebarLineHeight?: number | string;
    sidebarTextColor?: string;
    sidebarDisabledTextColor?: string;
    sidebarPadding?: string;
    sidebarActiveColor?: string;
    sidebarBackground?: string;
    sidebarSelectedFontWeight?: string;
    sidebarSelectedTextColor?: string;
    sidebarSelectedBorderWidth?: string;
    sidebarSelectedBorderHeight?: string;
    sidebarSelectedBorderColor?: string;
    sidebarSelectedBackground?: string;
};

type SidebarProps

type SidebarProps = ExtractPropTypes<typeof sidebarProps>;

type SidebarThemeVars

type SidebarThemeVars = {
    sidebarWidth?: string;
};

type SignatureInstance

type SignatureInstance = ComponentPublicInstance<SignatureProps, SignatureExpose>;

type SignatureProps

type SignatureProps = ExtractPropTypes<typeof signatureProps>;

type SignatureThemeVars

type SignatureThemeVars = {
    signaturePadding?: string;
    signatureContentHeight?: string;
    signatureContentBackground?: string;
    signatureContentBorder?: string;
};

type SkeletonAvatarProps

type SkeletonAvatarProps = ExtractPropTypes<typeof skeletonAvatarProps>;

type SkeletonAvatarShape

type SkeletonAvatarShape = 'square' | 'round';

type SkeletonImageProps

type SkeletonImageProps = ExtractPropTypes<typeof skeletonImageProps>;

type SkeletonImageShape

type SkeletonImageShape = 'square' | 'round';

type SkeletonParagraphProps

type SkeletonParagraphProps = ExtractPropTypes<typeof skeletonParagraphProps>;

type SkeletonProps

type SkeletonProps = ExtractPropTypes<typeof skeletonProps>;

type SkeletonThemeVars

type SkeletonThemeVars = {
    skeletonParagraphHeight?: string;
    skeletonParagraphBackground?: string;
    skeletonParagraphMarginTop?: string;
    skeletonTitleWidth?: string;
    skeletonAvatarSize?: string;
    skeletonAvatarBackground?: string;
    SkeletonImageSize?: string;
    SkeletonImageRadius?: string;
    skeletonDuration?: string;
};

type SkeletonTitleProps

type SkeletonTitleProps = ExtractPropTypes<typeof skeletonTitleProps>;

type SliderProps

type SliderProps = ExtractPropTypes<typeof sliderProps>;

type SliderThemeVars

type SliderThemeVars = {
    sliderActiveBackground?: string;
    sliderInactiveBackground?: string;
    sliderDisabledOpacity?: number | string;
    sliderBarHeight?: string;
    sliderButtonWidth?: string;
    sliderButtonHeight?: string;
    sliderButtonRadius?: string;
    sliderButtonBackground?: string;
    sliderButtonShadow?: string;
};

type SpaceAlign

type SpaceAlign = 'start' | 'end' | 'center' | 'baseline';

type SpaceProps

type SpaceProps = ExtractPropTypes<typeof spaceProps>;

type SpaceSize

type SpaceSize = number | string;

type StepperProps

type StepperProps = ExtractPropTypes<typeof stepperProps>;

type StepperTheme

type StepperTheme = 'default' | 'round';

type StepperThemeVars

type StepperThemeVars = {
    stepperBackground?: string;
    stepperButtonIconColor?: string;
    stepperButtonDisabledColor?: string;
    stepperButtonDisabledIconColor?: string;
    stepperButtonRoundThemeColor?: string;
    stepperInputWidth?: string;
    stepperInputHeight?: string;
    stepperInputFontSize?: string;
    stepperInputLineHeight?: number | string;
    stepperInputTextColor?: string;
    stepperInputDisabledTextColor?: string;
    stepperInputDisabledBackground?: string;
    stepperRadius?: string;
};

type StepsDirection

type StepsDirection = 'horizontal' | 'vertical';

type StepsProps

type StepsProps = ExtractPropTypes<typeof stepsProps>;

type StepsThemeVars

type StepsThemeVars = {
    stepsBackground?: string;
};

type StepThemeVars

type StepThemeVars = {
    stepTextColor?: string;
    stepActiveColor?: string;
    stepProcessTextColor?: string;
    stepFontSize?: string;
    stepLineColor?: string;
    stepFinishLineColor?: string;
    stepFinishTextColor?: string;
    stepIconSize?: string;
    stepCircleSize?: string;
    stepCircleColor?: string;
    stepHorizontalTitleFontSize?: string;
};

type StickyPosition

type StickyPosition = 'top' | 'bottom';

type StickyProps

type StickyProps = ExtractPropTypes<typeof stickyProps>;

type StickyThemeVars

type StickyThemeVars = {
    stickyZIndex?: number | string;
};

type SubmitBarProps

type SubmitBarProps = ExtractPropTypes<typeof submitBarProps>;

type SubmitBarTextAlign

type SubmitBarTextAlign = 'left' | 'right';

type SubmitBarThemeVars

type SubmitBarThemeVars = {
    submitBarHeight?: string;
    submitBarZIndex?: number | string;
    submitBarBackground?: string;
    submitBarButtonWidth?: string;
    submitBarPriceColor?: string;
    submitBarPriceFontSize?: string;
    submitBarPriceIntegerFontSize?: string;
    submitBarPriceFont?: string;
    submitBarTextColor?: string;
    submitBarTextFontSize?: string;
    submitBarTipPadding?: string;
    submitBarTipFontSize?: string;
    submitBarTipLineHeight?: number | string;
    submitBarTipColor?: string;
    submitBarTipBackground?: string;
    submitBarTipIconSize?: string;
    submitBarButtonHeight?: string;
    submitBarPadding?: string;
};

type SwipeCellInstance

type SwipeCellInstance = ComponentPublicInstance<SwipeCellProps, SwipeCellExpose>;

type SwipeCellPosition

type SwipeCellPosition = SwipeCellSide | 'cell' | 'outside';

type SwipeCellProps

type SwipeCellProps = ExtractPropTypes<typeof swipeCellProps>;

type SwipeCellSide

type SwipeCellSide = 'left' | 'right';

type SwipeInstance

type SwipeInstance = ComponentPublicInstance<SwipeProps, SwipeExpose>;

type SwipeProps

type SwipeProps = ExtractPropTypes<typeof swipeProps>;

type SwipeThemeVars

type SwipeThemeVars = {
    swipeIndicatorSize?: string;
    swipeIndicatorMargin?: string;
    swipeIndicatorActiveOpacity?: number | string;
    swipeIndicatorInactiveOpacity?: number | string;
    swipeIndicatorActiveBackground?: string;
    swipeIndicatorInactiveBackground?: string;
};

type SwipeToOptions

type SwipeToOptions = {
    immediate?: boolean;
};

type SwitchProps

type SwitchProps = ExtractPropTypes<typeof switchProps>;

type SwitchThemeVars

type SwitchThemeVars = {
    switchSize?: string;
    switchWidth?: string;
    switchHeight?: string;
    switchNodeSize?: string;
    switchNodeBackground?: string;
    switchNodeShadow?: string;
    switchBackground?: string;
    switchOnBackground?: string;
    switchDuration?: string;
    switchDisabledOpacity?: number | string;
};

type TabbarItemProps

type TabbarItemProps = ExtractPropTypes<typeof tabbarItemProps>;

type TabbarItemThemeVars

type TabbarItemThemeVars = {
    tabbarItemFontSize?: string;
    tabbarItemTextColor?: string;
    tabbarItemActiveColor?: string;
    tabbarItemActiveBackground?: string;
    tabbarItemLineHeight?: number | string;
    tabbarItemIconSize?: string;
    tabbarItemIconMarginBottom?: string;
};

type TabbarProps

type TabbarProps = ExtractPropTypes<typeof tabbarProps>;

type TabbarThemeVars

type TabbarThemeVars = {
    tabbarHeight?: string;
    tabbarZIndex?: number | string;
    tabbarBackground?: string;
};

type TabProps

type TabProps = ExtractPropTypes<typeof tabProps>;

type TabsInstance

type TabsInstance = ComponentPublicInstance<TabsProps, TabsExpose>;

type TabsProps

type TabsProps = ExtractPropTypes<typeof tabsProps>;

type TabsThemeVars

type TabsThemeVars = {
    tabTextColor?: string;
    tabActiveTextColor?: string;
    tabDisabledTextColor?: string;
    tabFontSize?: string;
    tabLineHeight?: number | string;
    tabsDefaultColor?: string;
    tabsLineHeight?: number | string;
    tabsCardHeight?: string;
    tabsNavBackground?: string;
    tabsBottomBarWidth?: string;
    tabsBottomBarHeight?: string;
    tabsBottomBarColor?: string;
};

type TabsType

type TabsType = 'line' | 'card';

type TagProps

type TagProps = ExtractPropTypes<typeof tagProps>;

type TagSize

type TagSize = 'large' | 'medium';

type TagThemeVars

type TagThemeVars = {
    tagPadding?: string;
    tagTextColor?: string;
    tagFontSize?: string;
    tagRadius?: string;
    tagLineHeight?: number | string;
    tagMediumPadding?: string;
    tagLargePadding?: string;
    tagLargeRadius?: string;
    tagLargeFontSize?: string;
    tagRoundRadius?: string;
    tagDangerColor?: string;
    tagPrimaryColor?: string;
    tagSuccessColor?: string;
    tagWarningColor?: string;
    tagDefaultColor?: string;
    tagPlainBackground?: string;
};

type TagType

type TagType = 'default' | 'primary' | 'success' | 'warning' | 'danger';

type TextEllipsisInstance

type TextEllipsisInstance = ComponentPublicInstance<
    TextEllipsisProps,
    TextEllipsisExpose
>;

type TextEllipsisProps

type TextEllipsisProps = ExtractPropTypes<typeof textEllipsisProps>;

type TextEllipsisThemeVars

type TextEllipsisThemeVars = {
    textEllipsisActionColor?: string;
};

type TimePickerColumnType

type TimePickerColumnType = 'hour' | 'minute' | 'second';

type TimePickerInstance

type TimePickerInstance = ComponentPublicInstance<TimePickerProps, TimePickerExpose>;

type TimePickerProps

type TimePickerProps = ExtractPropTypes<typeof timePickerProps>;

type ToastOptions

type ToastOptions = {
    icon?: string;
    type?: ToastType;
    mask?: boolean;
    message?: Numeric;
    overlay?: boolean;
    duration?: number;
    teleport?: TeleportProps['to'];
    iconSize?: Numeric;
    position?: ToastPosition;
    className?: unknown;
    transition?: string;
    iconPrefix?: string;
    wordBreak?: ToastWordBreak;
    loadingType?: LoadingType;
    forbidClick?: boolean;
    closeOnClick?: boolean;
    overlayClass?: unknown;
    overlayStyle?: Record<string, any>;
    closeOnClickOverlay?: boolean;
    zIndex?: Numeric;
    onClose?: () => void;
    onOpened?: () => void;
};

type ToastPosition

type ToastPosition = 'top' | 'middle' | 'bottom';

type ToastProps

type ToastProps = ExtractPropTypes<typeof toastProps>;

type ToastThemeVars

type ToastThemeVars = {
    toastMaxWidth?: string;
    toastFontSize?: string;
    toastTextColor?: string;
    toastLoadingIconColor?: string;
    toastLineHeight?: number | string;
    toastRadius?: string;
    toastBackground?: string;
    toastIconSize?: string;
    toastTextMinWidth?: string;
    toastTextPadding?: string;
    toastDefaultPadding?: string;
    toastDefaultWidth?: string;
    toastDefaultMinHeight?: string;
    toastPositionTopDistance?: string;
    toastPositionBottomDistance?: string;
};

type ToastType

type ToastType = 'text' | 'loading' | 'success' | 'fail' | 'html';

type ToastWordBreak

type ToastWordBreak = 'break-all' | 'break-word' | 'normal';

type ToastWrapperInstance

type ToastWrapperInstance = ComponentPublicInstance<
    {
        message: Numeric;
    },
    {
        close: () => void;
        /**
         * @private
         */
        open: (props: Record<string, any>) => void;
    }
>;

type TreeSelectChild

type TreeSelectChild = {
    id: Numeric;
    text: string;
    disabled?: boolean;
};

type TreeSelectItem

type TreeSelectItem = {
    dot?: boolean;
    text: string;
    badge?: Numeric;
    children?: TreeSelectChild[];
    disabled?: boolean;
    className?: unknown;
};

type TreeSelectProps

type TreeSelectProps = ExtractPropTypes<typeof treeSelectProps>;

type TreeSelectThemeVars

type TreeSelectThemeVars = {
    treeSelectFontSize?: string;
    treeSelectNavBackground?: string;
    treeSelectContentBackground?: string;
    treeSelectNavItemPadding?: string;
    treeSelectItemHeight?: string;
    treeSelectItemActiveColor?: string;
    treeSelectItemDisabledColor?: string;
    treeSelectItemSelectedSize?: string;
};

type UploaderAfterRead

type UploaderAfterRead = (
    items: UploaderFileListItem | UploaderFileListItem[],
    detail: {
        name: Numeric;
        index: number;
    }
) => void;

type UploaderBeforeRead

type UploaderBeforeRead = (
    file: File | File[],
    detail: {
        name: Numeric;
        index: number;
    }
) => boolean | undefined | Promise<File | File[] | undefined>;

type UploaderFileListItem

type UploaderFileListItem = {
    url?: string;
    file?: File;
    objectUrl?: string;
    content?: string;
    isImage?: boolean;
    status?: '' | 'uploading' | 'done' | 'failed';
    message?: string;
    imageFit?: ImageFit;
    deletable?: boolean;
    reupload?: boolean;
    previewSize?: Numeric;
    beforeDelete?: Interceptor;
};

type UploaderInstance

type UploaderInstance = ComponentPublicInstance<UploaderProps, UploaderExpose>;

type UploaderProps

type UploaderProps = ExtractPropTypes<typeof uploaderProps>;

type UploaderResultType

type UploaderResultType = 'dataUrl' | 'text' | 'file';

type UploaderThemeVars

type UploaderThemeVars = {
    uploaderSize?: string;
    uploaderIconSize?: string;
    uploaderIconColor?: string;
    uploaderTextColor?: string;
    uploaderTextFontSize?: string;
    uploaderUploadBackground?: string;
    uploaderUploadActiveColor?: string;
    uploaderDeleteColor?: string;
    uploaderDeleteIconSize?: string;
    uploaderDeleteBackground?: string;
    uploaderFileBackground?: string;
    uploaderFileIconSize?: string;
    uploaderFileIconColor?: string;
    uploaderFileNamePadding?: string;
    uploaderFileNameMarginTop?: string;
    uploaderFileNameFontSize?: string;
    uploaderFileNameTextColor?: string;
    uploaderMaskTextColor?: string;
    uploaderMaskBackground?: string;
    uploaderMaskIconSize?: string;
    uploaderMaskMessageFontSize?: string;
    uploaderMaskMessageLineHeight?: number | string;
    uploaderLoadingIconSize?: string;
    uploaderLoadingIconColor?: string;
    uploaderDisabledOpacity?: number | string;
};

type WatermarkProps

type WatermarkProps = ExtractPropTypes<typeof watermarkProps>;

type WatermarkThemeVars

type WatermarkThemeVars = {
    watermarkZIndex?: number | string;
};

Namespaces

namespace _default

namespace _default {}

variable version

const version: string;

function install

install: (app: any) => void;

namespace *.vue

module '*.vue' {}

variable Component

const Component: DefineComponent;

Package Files (292)

Dependencies (3)

Dev Dependencies (19)

Peer Dependencies (1)

Badge

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

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

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/vant)

HTML

<a href="https://www.jsdocs.io/package/vant"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 11 days ago.
Package analyzed in 15937 ms.
Missing or incorrect documentation? Open an issue for this package.