@vunk/form 2.14.0 → 2.14.1

package/components/van-cascader/src/index.vue.d.ts

@@ -0,0 +1,2093 @@
+import 'vant/es/cascader/style';
+import 'vant/es/popup/style';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    optionsUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    cascaderSlots: {
+        type: import("vue").PropType<import("@vunk/shared").NormalObject>;
+        default: () => {};
+    };
+    cascaderRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    required: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    formItemTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    formItemTipClass: any;
+    labelTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    information: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    prop: any;
+    label: StringConstructor;
+    labelWidth: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    labelPosition: {
+        readonly type: import("vue").PropType<"" | "top" | "left" | "right">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    rules: {
+        readonly type: import("vue").PropType<unknown>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<"" | "error" | "success" | "validating">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: {
+        readonly type: import("vue").PropType<string | boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    showMessage: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    emptyValues: ArrayConstructor;
+    valueOnClear: {
+        readonly type: import("vue").PropType<string | number | boolean | Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    size: {
+        readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    placeholder: StringConstructor;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    filterMethod: {
+        readonly type: import("vue").PropType<(node: import("element-plus").CascaderNode, keyword: string) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: (node: import("element-plus").CascaderNode, keyword: string) => boolean;
+    };
+    separator: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    showAllLevels: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: number;
+    };
+    collapseTagsTooltip: BooleanConstructor;
+    maxCollapseTagsTooltipHeight: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    debounce: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: number;
+    };
+    beforeFilter: {
+        readonly type: import("vue").PropType<(value: string) => boolean | Promise<any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => true;
+    };
+    placement: {
+        readonly type: import("vue").PropType<import("element-plus").Placement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    fallbackPlacements: {
+        readonly type: import("vue").PropType<import("element-plus").Placement[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string[];
+    };
+    popperClass: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    teleported: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    tagType: {
+        default: string;
+        type: import("vue").PropType<"primary" | "success" | "warning" | "info" | "danger">;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagEffect: {
+        default: string;
+        type: import("vue").PropType<"dark" | "light" | "plain">;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    persistent: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    modelValue: {
+        readonly type: import("vue").PropType<(string | number)[] | (string | number) | ((string | number)[] | (string | number))[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: {
+        readonly type: import("vue").PropType<import("element-plus").CascaderOption[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => import("element-plus").CascaderOption[];
+    };
+    props: {
+        readonly type: import("vue").PropType<import("element-plus").CascaderProps>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => import("element-plus").CascaderProps;
+    };
+}>, {
+    formItemBindProps: import("vue").ComputedRef<{}>;
+    fieldValue: import("vue").Ref<string, string>;
+    popupShow: import("vue").Ref<boolean, boolean>;
+    handleFinish: ({ selectedOptions }: {
+        selectedOptions: any;
+    }) => void;
+    cascaderValue: import("vue").Ref<string, string>;
+    options: import("vue").ComputedRef<import("element-plus").CascaderOption[]>;
+    preInput: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("element-plus").CascaderValue) => boolean;
+    change: (value: import("element-plus").CascaderValue) => boolean;
+    focus: (evt: FocusEvent) => boolean;
+    blur: (evt: FocusEvent) => boolean;
+    clear: () => boolean;
+    visibleChange: (val: boolean) => boolean;
+    expandChange: (val: import("element-plus").CascaderValue) => boolean;
+    removeTag: (val: import("element-plus").CascaderNode["valueByOption"]) => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    optionsUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    cascaderSlots: {
+        type: import("vue").PropType<import("@vunk/shared").NormalObject>;
+        default: () => {};
+    };
+    cascaderRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    required: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    formItemTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    formItemTipClass: any;
+    labelTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    information: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    prop: any;
+    label: StringConstructor;
+    labelWidth: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    labelPosition: {
+        readonly type: import("vue").PropType<"" | "top" | "left" | "right">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    rules: {
+        readonly type: import("vue").PropType<unknown>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<"" | "error" | "success" | "validating">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: {
+        readonly type: import("vue").PropType<string | boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    showMessage: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    emptyValues: ArrayConstructor;
+    valueOnClear: {
+        readonly type: import("vue").PropType<string | number | boolean | Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    size: {
+        readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    placeholder: StringConstructor;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    filterMethod: {
+        readonly type: import("vue").PropType<(node: import("element-plus").CascaderNode, keyword: string) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: (node: import("element-plus").CascaderNode, keyword: string) => boolean;
+    };
+    separator: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    showAllLevels: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: number;
+    };
+    collapseTagsTooltip: BooleanConstructor;
+    maxCollapseTagsTooltipHeight: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    debounce: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: number;
+    };
+    beforeFilter: {
+        readonly type: import("vue").PropType<(value: string) => boolean | Promise<any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => true;
+    };
+    placement: {
+        readonly type: import("vue").PropType<import("element-plus").Placement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    fallbackPlacements: {
+        readonly type: import("vue").PropType<import("element-plus").Placement[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string[];
+    };
+    popperClass: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    teleported: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    tagType: {
+        default: string;
+        type: import("vue").PropType<"primary" | "success" | "warning" | "info" | "danger">;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagEffect: {
+        default: string;
+        type: import("vue").PropType<"dark" | "light" | "plain">;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    persistent: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    modelValue: {
+        readonly type: import("vue").PropType<(string | number)[] | (string | number) | ((string | number)[] | (string | number))[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: {
+        readonly type: import("vue").PropType<import("element-plus").CascaderOption[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => import("element-plus").CascaderOption[];
+    };
+    props: {
+        readonly type: import("vue").PropType<import("element-plus").CascaderProps>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => import("element-plus").CascaderProps;
+    };
+}>> & Readonly<{
+    onFocus?: (evt: FocusEvent) => any;
+    onClear?: () => any;
+    "onUpdate:modelValue"?: (value: import("element-plus").CascaderValue) => any;
+    onChange?: (value: import("element-plus").CascaderValue) => any;
+    onBlur?: (evt: FocusEvent) => any;
+    onVisibleChange?: (val: boolean) => any;
+    onExpandChange?: (val: import("element-plus").CascaderValue) => any;
+    onRemoveTag?: (val: (string | number)[] | (string | number)) => any;
+}>, {
+    required: boolean;
+    formItemSize: "default" | "small" | "large";
+    formItemSlots: import("@vunk/form/components/form-item/src/types").FormItemSlots;
+    inline: boolean;
+    readonly: boolean;
+    formItemTip: string;
+    formItemTipClass: any;
+    labelTip: string;
+    information: boolean;
+    prop: any;
+    labelWidth: string | number;
+    labelPosition: "" | "top" | "left" | "right";
+    inlineMessage: string | boolean;
+    showMessage: boolean;
+    disabled: boolean;
+    persistent: boolean;
+    teleported: boolean;
+    popperClass: string;
+    fallbackPlacements: import("element-plus").Placement[];
+    placement: import("element-plus").Placement;
+    props: import("element-plus").CascaderProps;
+    clearable: boolean;
+    filterMethod: (node: import("element-plus").CascaderNode, keyword: string) => boolean;
+    options: import("element-plus").CascaderOption[];
+    validateEvent: boolean;
+    filterable: boolean;
+    collapseTags: boolean;
+    collapseTagsTooltip: boolean;
+    tagType: "primary" | "success" | "warning" | "info" | "danger";
+    valueOnClear: string | number | boolean | Function;
+    separator: string;
+    showAllLevels: boolean;
+    maxCollapseTags: number;
+    debounce: number;
+    beforeFilter: (value: string) => boolean | Promise<any>;
+    tagEffect: "dark" | "light" | "plain";
+    optionsUrl: string;
+    cascaderSlots: import("@vunk/shared").NormalObject;
+}, {}, {
+    VkfFormItem: {
+        new (...args: any[]): any;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<Record<string | symbol, any>>>, Record<string | symbol, any>, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        [x: string]: any;
+        [x: symbol]: any;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install(app: import("vue").App): void;
+    };
+    Cascader: import("vant/lib/utils").WithInstall<import("vue").DefineComponent<{
+        title: StringConstructor;
+        options: {
+            type: import("vue").PropType<import("vant").CascaderOption[]>;
+            default: () => never[];
+        };
+        closeable: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        swipeable: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        closeIcon: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        showHeader: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        modelValue: (NumberConstructor | StringConstructor)[];
+        fieldNames: import("vue").PropType<import("vant").CascaderFieldNames>;
+        placeholder: StringConstructor;
+        activeColor: StringConstructor;
+    }, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "close" | "clickTab" | "finish")[], "update:modelValue" | "change" | "close" | "clickTab" | "finish", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        title: StringConstructor;
+        options: {
+            type: import("vue").PropType<import("vant").CascaderOption[]>;
+            default: () => never[];
+        };
+        closeable: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        swipeable: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        closeIcon: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        showHeader: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        modelValue: (NumberConstructor | StringConstructor)[];
+        fieldNames: import("vue").PropType<import("vant").CascaderFieldNames>;
+        placeholder: StringConstructor;
+        activeColor: StringConstructor;
+    }>> & {
+        onChange?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        onClose?: ((...args: any[]) => any) | undefined;
+        onClickTab?: ((...args: any[]) => any) | undefined;
+        onFinish?: ((...args: any[]) => any) | undefined;
+    }, {
+        closeIcon: string;
+        closeable: boolean;
+        options: import("vant").CascaderOption[];
+        swipeable: boolean;
+        showHeader: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+    Popup: import("vant/lib/utils").WithInstall<import("vue").DefineComponent<{
+        show: BooleanConstructor;
+        zIndex: (NumberConstructor | StringConstructor)[];
+        overlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        duration: (NumberConstructor | StringConstructor)[];
+        teleport: import("vue").PropType<string | import("vue").RendererElement | null | undefined>;
+        lockScroll: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        lazyRender: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        beforeClose: import("vue").PropType<import("vant/lib/utils").Interceptor>;
+        overlayStyle: import("vue").PropType<import("vue").CSSProperties>;
+        overlayClass: import("vue").PropType<unknown>;
+        transitionAppear: BooleanConstructor;
+        closeOnClickOverlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+    } & {
+        round: BooleanConstructor;
+        position: {
+            type: import("vue").PropType<import("vant").PopupPosition>;
+            default: import("vant").PopupPosition;
+        };
+        closeIcon: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        closeable: BooleanConstructor;
+        transition: StringConstructor;
+        iconPrefix: StringConstructor;
+        closeOnPopstate: BooleanConstructor;
+        closeIconPosition: {
+            type: import("vue").PropType<import("vant").PopupCloseIconPosition>;
+            default: import("vant").PopupCloseIconPosition;
+        };
+        safeAreaInsetTop: BooleanConstructor;
+        safeAreaInsetBottom: BooleanConstructor;
+    }, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("open" | "keydown" | "close" | "opened" | "closed" | "update:show" | "clickOverlay" | "clickCloseIcon")[], "open" | "keydown" | "close" | "opened" | "closed" | "update:show" | "clickOverlay" | "clickCloseIcon", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        show: BooleanConstructor;
+        zIndex: (NumberConstructor | StringConstructor)[];
+        overlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        duration: (NumberConstructor | StringConstructor)[];
+        teleport: import("vue").PropType<string | import("vue").RendererElement | null | undefined>;
+        lockScroll: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        lazyRender: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        beforeClose: import("vue").PropType<import("vant/lib/utils").Interceptor>;
+        overlayStyle: import("vue").PropType<import("vue").CSSProperties>;
+        overlayClass: import("vue").PropType<unknown>;
+        transitionAppear: BooleanConstructor;
+        closeOnClickOverlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+    } & {
+        round: BooleanConstructor;
+        position: {
+            type: import("vue").PropType<import("vant").PopupPosition>;
+            default: import("vant").PopupPosition;
+        };
+        closeIcon: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        closeable: BooleanConstructor;
+        transition: StringConstructor;
+        iconPrefix: StringConstructor;
+        closeOnPopstate: BooleanConstructor;
+        closeIconPosition: {
+            type: import("vue").PropType<import("vant").PopupCloseIconPosition>;
+            default: import("vant").PopupCloseIconPosition;
+        };
+        safeAreaInsetTop: BooleanConstructor;
+        safeAreaInsetBottom: BooleanConstructor;
+    }>> & {
+        onKeydown?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        onClose?: ((...args: any[]) => any) | undefined;
+        onOpened?: ((...args: any[]) => any) | undefined;
+        onClosed?: ((...args: any[]) => any) | undefined;
+        "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+        onClickOverlay?: ((...args: any[]) => any) | undefined;
+        onClickCloseIcon?: ((...args: any[]) => any) | undefined;
+    }, {
+        position: import("vant").PopupPosition;
+        round: boolean;
+        overlay: boolean;
+        show: boolean;
+        safeAreaInsetBottom: boolean;
+        lockScroll: boolean;
+        lazyRender: boolean;
+        transitionAppear: boolean;
+        closeOnClickOverlay: boolean;
+        closeIcon: string;
+        closeable: boolean;
+        closeOnPopstate: boolean;
+        closeIconPosition: import("vant").PopupCloseIconPosition;
+        safeAreaInsetTop: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+    ElSelect: ({
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            ariaLabel: StringConstructor;
+            emptyValues: ArrayConstructor;
+            valueOnClear: {
+                readonly type: import("vue").PropType<string | number | boolean | Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            name: StringConstructor;
+            id: StringConstructor;
+            modelValue: {
+                readonly type: import("vue").PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            autocomplete: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            automaticDropdown: BooleanConstructor;
+            size: {
+                readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            effect: {
+                readonly type: import("vue").PropType<import("element-plus").PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            disabled: BooleanConstructor;
+            clearable: BooleanConstructor;
+            filterable: BooleanConstructor;
+            allowCreate: BooleanConstructor;
+            loading: BooleanConstructor;
+            popperClass: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            popperOptions: {
+                readonly type: import("vue").PropType<Partial<import("element-plus").Options>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => Partial<import("element-plus").Options>;
+            };
+            remote: BooleanConstructor;
+            loadingText: StringConstructor;
+            noMatchText: StringConstructor;
+            noDataText: StringConstructor;
+            remoteMethod: FunctionConstructor;
+            filterMethod: FunctionConstructor;
+            multiple: BooleanConstructor;
+            multipleLimit: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            placeholder: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            defaultFirstOption: BooleanConstructor;
+            reserveKeyword: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            valueKey: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            collapseTags: BooleanConstructor;
+            collapseTagsTooltip: BooleanConstructor;
+            maxCollapseTags: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            teleported: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            persistent: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            clearIcon: {
+                readonly type: import("vue").PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            fitInputWidth: BooleanConstructor;
+            suffixIcon: {
+                readonly type: import("vue").PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tagType: {
+                default: string;
+                type: import("vue").PropType<"primary" | "success" | "warning" | "info" | "danger">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tagEffect: {
+                default: string;
+                type: import("vue").PropType<"dark" | "light" | "plain">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            validateEvent: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            remoteShowSuffix: BooleanConstructor;
+            showArrow: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            offset: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            placement: {
+                readonly type: import("vue").PropType<import("element-plus").Placement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            fallbackPlacements: {
+                readonly type: import("vue").PropType<import("element-plus").Placement[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string[];
+            };
+            tabindex: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            appendTo: {
+                readonly type: import("vue").PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onChange?: ((...args: any[]) => any) | undefined;
+            onFocus?: ((...args: any[]) => any) | undefined;
+            onBlur?: ((...args: any[]) => any) | undefined;
+            onClear?: ((...args: any[]) => any) | undefined;
+            "onVisible-change"?: ((...args: any[]) => any) | undefined;
+            "onRemove-tag"?: ((...args: any[]) => any) | undefined;
+            "onPopup-scroll"?: ((...args: any[]) => any) | undefined;
+        }, {
+            modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
+            selectedLabel: import("vue").ComputedRef<string | string[]>;
+            calculatorRef: import("vue").ShallowRef<HTMLElement | undefined>;
+            inputStyle: import("vue").ComputedRef<{
+                minWidth: string;
+            }>;
+            inputId: import("vue").Ref<string | undefined>;
+            contentId: import("vue").Ref<string>;
+            nsSelect: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            nsInput: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            states: {
+                inputValue: string;
+                options: Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy> & Omit<Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
+                cachedOptions: Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy> & Omit<Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
+                optionValues: (string | number | boolean | Record<string, any>)[];
+                selected: {
+                    value: string | number | boolean | Record<string, any>;
+                    currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+                    isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+                }[];
+                hoveringIndex: number;
+                inputHovering: boolean;
+                selectionWidth: number;
+                collapseItemWidth: number;
+                previousQuery: string | null;
+                selectedLabel: string;
+                menuVisibleOnFocus: boolean;
+                isBeforeHide: boolean;
+            };
+            isFocused: import("vue").Ref<boolean>;
+            expanded: import("vue").Ref<boolean>;
+            optionsArray: import("vue").ComputedRef<import("element-plus").SelectOptionProxy[]>;
+            hoverOption: import("vue").Ref<any>;
+            selectSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+            filteredOptionsCount: import("vue").ComputedRef<number>;
+            updateTooltip: () => void;
+            updateTagTooltip: () => void;
+            debouncedOnInputChange: import("lodash").DebouncedFunc<() => void>;
+            onInput: (event: Event) => void;
+            deletePrevTag: (e: KeyboardEvent) => void;
+            deleteTag: (event: MouseEvent, tag: import("element-plus").SelectOptionProxy | import("element-plus").OptionBasic) => void;
+            deleteSelected: (event: Event) => void;
+            handleOptionSelect: (option: import("element-plus").SelectOptionProxy) => void;
+            scrollToOption: (option: import("element-plus").SelectOptionProxy | import("element-plus").SelectOptionProxy[] | import("element-plus").OptionBasic[]) => void;
+            hasModelValue: import("vue").ComputedRef<boolean>;
+            shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
+            currentPlaceholder: import("vue").ComputedRef<string>;
+            mouseEnterEventName: import("vue").ComputedRef<"mouseenter" | null>;
+            needStatusIcon: import("vue").ComputedRef<boolean>;
+            showClose: import("vue").ComputedRef<boolean>;
+            iconComponent: import("vue").ComputedRef<unknown | undefined>;
+            iconReverse: import("vue").ComputedRef<string>;
+            validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+            validateIcon: import("vue").ComputedRef<"" | import("vue").Component>;
+            showNewOption: import("vue").ComputedRef<boolean>;
+            updateOptions: () => void;
+            collapseTagSize: import("vue").ComputedRef<"default" | "small">;
+            setSelected: () => void;
+            selectDisabled: import("vue").ComputedRef<boolean>;
+            emptyText: import("vue").ComputedRef<string | null>;
+            handleCompositionStart: (event: CompositionEvent) => void;
+            handleCompositionUpdate: (event: CompositionEvent) => void;
+            handleCompositionEnd: (event: CompositionEvent) => void;
+            onOptionCreate: (vm: import("element-plus").SelectOptionProxy) => void;
+            onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import("element-plus").SelectOptionProxy) => void;
+            handleMenuEnter: () => void;
+            focus: () => void;
+            blur: () => void;
+            handleClearClick: (event: Event) => void;
+            handleClickOutside: (event: Event) => void;
+            handleEsc: () => void;
+            toggleMenu: () => void;
+            selectOption: () => void;
+            getValueKey: (item: import("element-plus").SelectOptionProxy | import("element-plus").OptionBasic) => any;
+            navigateOptions: (direction: "prev" | "next") => void;
+            dropdownMenuVisible: import("vue").WritableComputedRef<boolean>;
+            showTagList: import("vue").ComputedRef<{
+                value: string | number | boolean | Record<string, any>;
+                currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+                isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+            }[]>;
+            collapseTagList: import("vue").ComputedRef<{
+                value: string | number | boolean | Record<string, any>;
+                currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+                isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+            }[]>;
+            popupScroll: (data: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            tagStyle: import("vue").ComputedRef<{
+                maxWidth: string;
+            }>;
+            collapseTagStyle: import("vue").ComputedRef<{
+                maxWidth: string;
+            }>;
+            popperRef: import("vue").ComputedRef<HTMLElement | undefined>;
+            inputRef: import("vue").Ref<HTMLInputElement | undefined>;
+            tooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined>;
+            tagTooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined>;
+            prefixRef: import("vue").Ref<HTMLElement | undefined>;
+            suffixRef: import("vue").Ref<HTMLElement | undefined>;
+            selectRef: import("vue").Ref<HTMLElement | undefined>;
+            wrapperRef: import("vue").ShallowRef<HTMLElement | undefined>;
+            selectionRef: import("vue").Ref<HTMLElement | undefined>;
+            scrollbarRef: import("vue").Ref<import("element-plus").ScrollbarInstance | undefined>;
+            menuRef: import("vue").Ref<HTMLElement | undefined>;
+            tagMenuRef: import("vue").Ref<HTMLElement | undefined>;
+            collapseItemRef: import("vue").Ref<HTMLElement | undefined>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "clear" | "update:modelValue" | "change" | "blur" | "remove-tag" | "visible-change" | "popup-scroll")[], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
+            disabled: boolean;
+            offset: number;
+            multiple: boolean;
+            loading: boolean;
+            modelValue: unknown;
+            placement: import("element-plus").Placement;
+            effect: import("element-plus").PopperEffect;
+            tabindex: string | number;
+            valueOnClear: string | number | boolean | Function;
+            autocomplete: string;
+            validateEvent: boolean;
+            clearable: boolean;
+            fallbackPlacements: import("element-plus").Placement[];
+            popperOptions: Partial<import("element-plus").Options>;
+            popperClass: string;
+            teleported: boolean;
+            persistent: boolean;
+            showArrow: boolean;
+            valueKey: string;
+            fitInputWidth: boolean;
+            filterable: boolean;
+            collapseTags: boolean;
+            maxCollapseTags: number;
+            collapseTagsTooltip: boolean;
+            tagType: "primary" | "success" | "warning" | "info" | "danger";
+            tagEffect: "dark" | "light" | "plain";
+            automaticDropdown: boolean;
+            allowCreate: boolean;
+            remote: boolean;
+            multipleLimit: number;
+            defaultFirstOption: boolean;
+            reserveKeyword: boolean;
+            remoteShowSuffix: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            ariaLabel: StringConstructor;
+            emptyValues: ArrayConstructor;
+            valueOnClear: {
+                readonly type: import("vue").PropType<string | number | boolean | Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            name: StringConstructor;
+            id: StringConstructor;
+            modelValue: {
+                readonly type: import("vue").PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            autocomplete: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            automaticDropdown: BooleanConstructor;
+            size: {
+                readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            effect: {
+                readonly type: import("vue").PropType<import("element-plus").PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            disabled: BooleanConstructor;
+            clearable: BooleanConstructor;
+            filterable: BooleanConstructor;
+            allowCreate: BooleanConstructor;
+            loading: BooleanConstructor;
+            popperClass: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            popperOptions: {
+                readonly type: import("vue").PropType<Partial<import("element-plus").Options>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => Partial<import("element-plus").Options>;
+            };
+            remote: BooleanConstructor;
+            loadingText: StringConstructor;
+            noMatchText: StringConstructor;
+            noDataText: StringConstructor;
+            remoteMethod: FunctionConstructor;
+            filterMethod: FunctionConstructor;
+            multiple: BooleanConstructor;
+            multipleLimit: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            placeholder: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            defaultFirstOption: BooleanConstructor;
+            reserveKeyword: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            valueKey: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            collapseTags: BooleanConstructor;
+            collapseTagsTooltip: BooleanConstructor;
+            maxCollapseTags: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            teleported: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            persistent: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            clearIcon: {
+                readonly type: import("vue").PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            fitInputWidth: BooleanConstructor;
+            suffixIcon: {
+                readonly type: import("vue").PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tagType: {
+                default: string;
+                type: import("vue").PropType<"primary" | "success" | "warning" | "info" | "danger">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tagEffect: {
+                default: string;
+                type: import("vue").PropType<"dark" | "light" | "plain">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            validateEvent: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            remoteShowSuffix: BooleanConstructor;
+            showArrow: {
+                readonly type: import("vue").PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            offset: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            placement: {
+                readonly type: import("vue").PropType<import("element-plus").Placement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            fallbackPlacements: {
+                readonly type: import("vue").PropType<import("element-plus").Placement[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string[];
+            };
+            tabindex: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            appendTo: {
+                readonly type: import("vue").PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onChange?: ((...args: any[]) => any) | undefined;
+            onFocus?: ((...args: any[]) => any) | undefined;
+            onBlur?: ((...args: any[]) => any) | undefined;
+            onClear?: ((...args: any[]) => any) | undefined;
+            "onVisible-change"?: ((...args: any[]) => any) | undefined;
+            "onRemove-tag"?: ((...args: any[]) => any) | undefined;
+            "onPopup-scroll"?: ((...args: any[]) => any) | undefined;
+        }, {
+            modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
+            selectedLabel: import("vue").ComputedRef<string | string[]>;
+            calculatorRef: import("vue").ShallowRef<HTMLElement | undefined>;
+            inputStyle: import("vue").ComputedRef<{
+                minWidth: string;
+            }>;
+            inputId: import("vue").Ref<string | undefined>;
+            contentId: import("vue").Ref<string>;
+            nsSelect: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            nsInput: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            states: {
+                inputValue: string;
+                options: Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy> & Omit<Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
+                cachedOptions: Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy> & Omit<Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
+                optionValues: (string | number | boolean | Record<string, any>)[];
+                selected: {
+                    value: string | number | boolean | Record<string, any>;
+                    currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+                    isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+                }[];
+                hoveringIndex: number;
+                inputHovering: boolean;
+                selectionWidth: number;
+                collapseItemWidth: number;
+                previousQuery: string | null;
+                selectedLabel: string;
+                menuVisibleOnFocus: boolean;
+                isBeforeHide: boolean;
+            };
+            isFocused: import("vue").Ref<boolean>;
+            expanded: import("vue").Ref<boolean>;
+            optionsArray: import("vue").ComputedRef<import("element-plus").SelectOptionProxy[]>;
+            hoverOption: import("vue").Ref<any>;
+            selectSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+            filteredOptionsCount: import("vue").ComputedRef<number>;
+            updateTooltip: () => void;
+            updateTagTooltip: () => void;
+            debouncedOnInputChange: import("lodash").DebouncedFunc<() => void>;
+            onInput: (event: Event) => void;
+            deletePrevTag: (e: KeyboardEvent) => void;
+            deleteTag: (event: MouseEvent, tag: import("element-plus").SelectOptionProxy | import("element-plus").OptionBasic) => void;
+            deleteSelected: (event: Event) => void;
+            handleOptionSelect: (option: import("element-plus").SelectOptionProxy) => void;
+            scrollToOption: (option: import("element-plus").SelectOptionProxy | import("element-plus").SelectOptionProxy[] | import("element-plus").OptionBasic[]) => void;
+            hasModelValue: import("vue").ComputedRef<boolean>;
+            shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
+            currentPlaceholder: import("vue").ComputedRef<string>;
+            mouseEnterEventName: import("vue").ComputedRef<"mouseenter" | null>;
+            needStatusIcon: import("vue").ComputedRef<boolean>;
+            showClose: import("vue").ComputedRef<boolean>;
+            iconComponent: import("vue").ComputedRef<unknown | undefined>;
+            iconReverse: import("vue").ComputedRef<string>;
+            validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+            validateIcon: import("vue").ComputedRef<"" | import("vue").Component>;
+            showNewOption: import("vue").ComputedRef<boolean>;
+            updateOptions: () => void;
+            collapseTagSize: import("vue").ComputedRef<"default" | "small">;
+            setSelected: () => void;
+            selectDisabled: import("vue").ComputedRef<boolean>;
+            emptyText: import("vue").ComputedRef<string | null>;
+            handleCompositionStart: (event: CompositionEvent) => void;
+            handleCompositionUpdate: (event: CompositionEvent) => void;
+            handleCompositionEnd: (event: CompositionEvent) => void;
+            onOptionCreate: (vm: import("element-plus").SelectOptionProxy) => void;
+            onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import("element-plus").SelectOptionProxy) => void;
+            handleMenuEnter: () => void;
+            focus: () => void;
+            blur: () => void;
+            handleClearClick: (event: Event) => void;
+            handleClickOutside: (event: Event) => void;
+            handleEsc: () => void;
+            toggleMenu: () => void;
+            selectOption: () => void;
+            getValueKey: (item: import("element-plus").SelectOptionProxy | import("element-plus").OptionBasic) => any;
+            navigateOptions: (direction: "prev" | "next") => void;
+            dropdownMenuVisible: import("vue").WritableComputedRef<boolean>;
+            showTagList: import("vue").ComputedRef<{
+                value: string | number | boolean | Record<string, any>;
+                currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+                isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+            }[]>;
+            collapseTagList: import("vue").ComputedRef<{
+                value: string | number | boolean | Record<string, any>;
+                currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+                isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+            }[]>;
+            popupScroll: (data: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            tagStyle: import("vue").ComputedRef<{
+                maxWidth: string;
+            }>;
+            collapseTagStyle: import("vue").ComputedRef<{
+                maxWidth: string;
+            }>;
+            popperRef: import("vue").ComputedRef<HTMLElement | undefined>;
+            inputRef: import("vue").Ref<HTMLInputElement | undefined>;
+            tooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined>;
+            tagTooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined>;
+            prefixRef: import("vue").Ref<HTMLElement | undefined>;
+            suffixRef: import("vue").Ref<HTMLElement | undefined>;
+            selectRef: import("vue").Ref<HTMLElement | undefined>;
+            wrapperRef: import("vue").ShallowRef<HTMLElement | undefined>;
+            selectionRef: import("vue").Ref<HTMLElement | undefined>;
+            scrollbarRef: import("vue").Ref<import("element-plus").ScrollbarInstance | undefined>;
+            menuRef: import("vue").Ref<HTMLElement | undefined>;
+            tagMenuRef: import("vue").Ref<HTMLElement | undefined>;
+            collapseItemRef: import("vue").Ref<HTMLElement | undefined>;
+        }, {}, {}, {}, {
+            disabled: boolean;
+            offset: number;
+            multiple: boolean;
+            loading: boolean;
+            modelValue: unknown;
+            placement: import("element-plus").Placement;
+            effect: import("element-plus").PopperEffect;
+            tabindex: string | number;
+            valueOnClear: string | number | boolean | Function;
+            autocomplete: string;
+            validateEvent: boolean;
+            clearable: boolean;
+            fallbackPlacements: import("element-plus").Placement[];
+            popperOptions: Partial<import("element-plus").Options>;
+            popperClass: string;
+            teleported: boolean;
+            persistent: boolean;
+            showArrow: boolean;
+            valueKey: string;
+            fitInputWidth: boolean;
+            filterable: boolean;
+            collapseTags: boolean;
+            maxCollapseTags: number;
+            collapseTagsTooltip: boolean;
+            tagType: "primary" | "success" | "warning" | "info" | "danger";
+            tagEffect: "dark" | "light" | "plain";
+            automaticDropdown: boolean;
+            allowCreate: boolean;
+            remote: boolean;
+            multipleLimit: number;
+            defaultFirstOption: boolean;
+            reserveKeyword: boolean;
+            remoteShowSuffix: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        ariaLabel: StringConstructor;
+        emptyValues: ArrayConstructor;
+        valueOnClear: {
+            readonly type: import("vue").PropType<string | number | boolean | Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        name: StringConstructor;
+        id: StringConstructor;
+        modelValue: {
+            readonly type: import("vue").PropType<unknown>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        autocomplete: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        automaticDropdown: BooleanConstructor;
+        size: {
+            readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        effect: {
+            readonly type: import("vue").PropType<import("element-plus").PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        disabled: BooleanConstructor;
+        clearable: BooleanConstructor;
+        filterable: BooleanConstructor;
+        allowCreate: BooleanConstructor;
+        loading: BooleanConstructor;
+        popperClass: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        popperOptions: {
+            readonly type: import("vue").PropType<Partial<import("element-plus").Options>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => Partial<import("element-plus").Options>;
+        };
+        remote: BooleanConstructor;
+        loadingText: StringConstructor;
+        noMatchText: StringConstructor;
+        noDataText: StringConstructor;
+        remoteMethod: FunctionConstructor;
+        filterMethod: FunctionConstructor;
+        multiple: BooleanConstructor;
+        multipleLimit: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: number;
+        };
+        placeholder: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        defaultFirstOption: BooleanConstructor;
+        reserveKeyword: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        valueKey: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        collapseTags: BooleanConstructor;
+        collapseTagsTooltip: BooleanConstructor;
+        maxCollapseTags: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: number;
+        };
+        teleported: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        persistent: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        clearIcon: {
+            readonly type: import("vue").PropType<unknown>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        fitInputWidth: BooleanConstructor;
+        suffixIcon: {
+            readonly type: import("vue").PropType<unknown>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tagType: {
+            default: string;
+            type: import("vue").PropType<"primary" | "success" | "warning" | "info" | "danger">;
+            required: false;
+            validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tagEffect: {
+            default: string;
+            type: import("vue").PropType<"dark" | "light" | "plain">;
+            required: false;
+            validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        validateEvent: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        remoteShowSuffix: BooleanConstructor;
+        showArrow: {
+            readonly type: import("vue").PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        offset: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: number;
+        };
+        placement: {
+            readonly type: import("vue").PropType<import("element-plus").Placement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        fallbackPlacements: {
+            readonly type: import("vue").PropType<import("element-plus").Placement[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string[];
+        };
+        tabindex: {
+            readonly type: import("vue").PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: number;
+        };
+        appendTo: {
+            readonly type: import("vue").PropType<string | HTMLElement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        onChange?: ((...args: any[]) => any) | undefined;
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onClear?: ((...args: any[]) => any) | undefined;
+        "onVisible-change"?: ((...args: any[]) => any) | undefined;
+        "onRemove-tag"?: ((...args: any[]) => any) | undefined;
+        "onPopup-scroll"?: ((...args: any[]) => any) | undefined;
+    }, {
+        modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
+        selectedLabel: import("vue").ComputedRef<string | string[]>;
+        calculatorRef: import("vue").ShallowRef<HTMLElement | undefined>;
+        inputStyle: import("vue").ComputedRef<{
+            minWidth: string;
+        }>;
+        inputId: import("vue").Ref<string | undefined>;
+        contentId: import("vue").Ref<string>;
+        nsSelect: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        nsInput: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        states: {
+            inputValue: string;
+            options: Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy> & Omit<Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
+            cachedOptions: Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy> & Omit<Map<string | number | boolean | Record<string, any>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
+            optionValues: (string | number | boolean | Record<string, any>)[];
+            selected: {
+                value: string | number | boolean | Record<string, any>;
+                currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+                isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+            }[];
+            hoveringIndex: number;
+            inputHovering: boolean;
+            selectionWidth: number;
+            collapseItemWidth: number;
+            previousQuery: string | null;
+            selectedLabel: string;
+            menuVisibleOnFocus: boolean;
+            isBeforeHide: boolean;
+        };
+        isFocused: import("vue").Ref<boolean>;
+        expanded: import("vue").Ref<boolean>;
+        optionsArray: import("vue").ComputedRef<import("element-plus").SelectOptionProxy[]>;
+        hoverOption: import("vue").Ref<any>;
+        selectSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+        filteredOptionsCount: import("vue").ComputedRef<number>;
+        updateTooltip: () => void;
+        updateTagTooltip: () => void;
+        debouncedOnInputChange: import("lodash").DebouncedFunc<() => void>;
+        onInput: (event: Event) => void;
+        deletePrevTag: (e: KeyboardEvent) => void;
+        deleteTag: (event: MouseEvent, tag: import("element-plus").SelectOptionProxy | import("element-plus").OptionBasic) => void;
+        deleteSelected: (event: Event) => void;
+        handleOptionSelect: (option: import("element-plus").SelectOptionProxy) => void;
+        scrollToOption: (option: import("element-plus").SelectOptionProxy | import("element-plus").SelectOptionProxy[] | import("element-plus").OptionBasic[]) => void;
+        hasModelValue: import("vue").ComputedRef<boolean>;
+        shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
+        currentPlaceholder: import("vue").ComputedRef<string>;
+        mouseEnterEventName: import("vue").ComputedRef<"mouseenter" | null>;
+        needStatusIcon: import("vue").ComputedRef<boolean>;
+        showClose: import("vue").ComputedRef<boolean>;
+        iconComponent: import("vue").ComputedRef<unknown | undefined>;
+        iconReverse: import("vue").ComputedRef<string>;
+        validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+        validateIcon: import("vue").ComputedRef<"" | import("vue").Component>;
+        showNewOption: import("vue").ComputedRef<boolean>;
+        updateOptions: () => void;
+        collapseTagSize: import("vue").ComputedRef<"default" | "small">;
+        setSelected: () => void;
+        selectDisabled: import("vue").ComputedRef<boolean>;
+        emptyText: import("vue").ComputedRef<string | null>;
+        handleCompositionStart: (event: CompositionEvent) => void;
+        handleCompositionUpdate: (event: CompositionEvent) => void;
+        handleCompositionEnd: (event: CompositionEvent) => void;
+        onOptionCreate: (vm: import("element-plus").SelectOptionProxy) => void;
+        onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import("element-plus").SelectOptionProxy) => void;
+        handleMenuEnter: () => void;
+        focus: () => void;
+        blur: () => void;
+        handleClearClick: (event: Event) => void;
+        handleClickOutside: (event: Event) => void;
+        handleEsc: () => void;
+        toggleMenu: () => void;
+        selectOption: () => void;
+        getValueKey: (item: import("element-plus").SelectOptionProxy | import("element-plus").OptionBasic) => any;
+        navigateOptions: (direction: "prev" | "next") => void;
+        dropdownMenuVisible: import("vue").WritableComputedRef<boolean>;
+        showTagList: import("vue").ComputedRef<{
+            value: string | number | boolean | Record<string, any>;
+            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+        }[]>;
+        collapseTagList: import("vue").ComputedRef<{
+            value: string | number | boolean | Record<string, any>;
+            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
+            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
+        }[]>;
+        popupScroll: (data: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void;
+        tagStyle: import("vue").ComputedRef<{
+            maxWidth: string;
+        }>;
+        collapseTagStyle: import("vue").ComputedRef<{
+            maxWidth: string;
+        }>;
+        popperRef: import("vue").ComputedRef<HTMLElement | undefined>;
+        inputRef: import("vue").Ref<HTMLInputElement | undefined>;
+        tooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined>;
+        tagTooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined>;
+        prefixRef: import("vue").Ref<HTMLElement | undefined>;
+        suffixRef: import("vue").Ref<HTMLElement | undefined>;
+        selectRef: import("vue").Ref<HTMLElement | undefined>;
+        wrapperRef: import("vue").ShallowRef<HTMLElement | undefined>;
+        selectionRef: import("vue").Ref<HTMLElement | undefined>;
+        scrollbarRef: import("vue").Ref<import("element-plus").ScrollbarInstance | undefined>;
+        menuRef: import("vue").Ref<HTMLElement | undefined>;
+        tagMenuRef: import("vue").Ref<HTMLElement | undefined>;
+        collapseItemRef: import("vue").Ref<HTMLElement | undefined>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "clear" | "update:modelValue" | "change" | "blur" | "remove-tag" | "visible-change" | "popup-scroll")[], "focus" | "clear" | "update:modelValue" | "change" | "blur" | "remove-tag" | "visible-change" | "popup-scroll", {
+        disabled: boolean;
+        offset: number;
+        multiple: boolean;
+        loading: boolean;
+        modelValue: unknown;
+        placement: import("element-plus").Placement;
+        effect: import("element-plus").PopperEffect;
+        tabindex: string | number;
+        valueOnClear: string | number | boolean | Function;
+        autocomplete: string;
+        validateEvent: boolean;
+        clearable: boolean;
+        fallbackPlacements: import("element-plus").Placement[];
+        popperOptions: Partial<import("element-plus").Options>;
+        popperClass: string;
+        teleported: boolean;
+        persistent: boolean;
+        showArrow: boolean;
+        valueKey: string;
+        fitInputWidth: boolean;
+        filterable: boolean;
+        collapseTags: boolean;
+        maxCollapseTags: number;
+        collapseTagsTooltip: boolean;
+        tagType: "primary" | "success" | "warning" | "info" | "danger";
+        tagEffect: "dark" | "light" | "plain";
+        automaticDropdown: boolean;
+        allowCreate: boolean;
+        remote: boolean;
+        multipleLimit: number;
+        defaultFirstOption: boolean;
+        reserveKeyword: boolean;
+        remoteShowSuffix: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin) & {
+        Option: import("vue").DefineComponent<{
+            value: {
+                readonly type: import("vue").PropType<string | number | boolean | Record<string, any>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            label: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            created: BooleanConstructor;
+            disabled: BooleanConstructor;
+        }, {
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            id: import("vue").Ref<string>;
+            containerKls: import("vue").ComputedRef<string[]>;
+            currentLabel: import("vue").ComputedRef<boolean | (string | number)>;
+            itemSelected: import("vue").ComputedRef<boolean>;
+            isDisabled: import("vue").ComputedRef<boolean>;
+            select: import("element-plus").SelectContext;
+            visible: import("vue").Ref<boolean>;
+            hover: import("vue").Ref<boolean>;
+            states: {
+                index: number;
+                groupDisabled: boolean;
+                visible: boolean;
+                hover: boolean;
+            };
+            hoverItem: () => void;
+            updateOption: (query: string) => void;
+            selectOptionClick: () => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                readonly type: import("vue").PropType<string | number | boolean | Record<string, any>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            label: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            created: BooleanConstructor;
+            disabled: BooleanConstructor;
+        }>>, {
+            disabled: boolean;
+            created: boolean;
+        }>;
+        OptionGroup: import("vue").DefineComponent<{
+            label: StringConstructor;
+            disabled: BooleanConstructor;
+        }, {
+            groupRef: import("vue").Ref<HTMLElement | undefined>;
+            visible: import("vue").ComputedRef<boolean>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            label: StringConstructor;
+            disabled: BooleanConstructor;
+        }>>, {
+            disabled: boolean;
+        }>;
+    };
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;