ra-element 0.1.4 → 0.1.6

package/lib/components/ra-select/index.vue.d.ts

@@ -15,1670 +15,1782 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    modelValue: {
-        type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
-        default: string;
-    };
-    options: {
-        type: PropType<SelectOptions[]>;
-        default: () => never[];
-    };
-    collapseTags: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    clearable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    multiple: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, {
-    component: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-        ariaLabel: StringConstructor;
-        emptyValues: ArrayConstructor;
-        valueOnClear: {
-            readonly type: PropType<string | number | boolean | Function>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        name: StringConstructor;
-        id: StringConstructor;
+declare const __VLS_component: import('vue').DefineComponent<
+    import('vue').ExtractPropTypes<{
         modelValue: {
-            readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        autocomplete: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        automaticDropdown: BooleanConstructor;
-        size: {
-            readonly type: PropType<"" | "default" | "small" | "large">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        effect: {
-            readonly type: 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: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        popperOptions: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: () => Partial<Options>;
-        };
-        remote: BooleanConstructor;
-        loadingText: StringConstructor;
-        noMatchText: StringConstructor;
-        noDataText: StringConstructor;
-        remoteMethod: FunctionConstructor;
-        filterMethod: FunctionConstructor;
-        multiple: BooleanConstructor;
-        multipleLimit: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        placeholder: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        defaultFirstOption: BooleanConstructor;
-        reserveKeyword: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        valueKey: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        collapseTags: BooleanConstructor;
-        collapseTagsTooltip: BooleanConstructor;
-        maxCollapseTags: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        teleported: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: true;
-        };
-        persistent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        clearIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        fitInputWidth: BooleanConstructor;
-        suffixIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        tagType: {
-            default: string;
-            type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        tagEffect: {
+            type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
             default: string;
-            type: PropType<"plain" | "dark" | "light">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        validateEvent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        remoteShowSuffix: BooleanConstructor;
-        showArrow: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        offset: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        placement: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        fallbackPlacements: {
-            readonly type: PropType<Placement[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string[];
-        };
-        tabindex: {
-            readonly type: PropType<string | number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        appendTo: {
-            readonly type: 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>;
-            cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
-            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-es').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<(string | import('vue').Component) | 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, ("blur" | "change" | "focus" | "clear" | "update:modelValue" | "visible-change" | "remove-tag" | "popup-scroll")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
-        disabled: boolean;
-        offset: number;
-        multiple: boolean;
-        loading: boolean;
-        modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
-        placement: any;
-        effect: import('element-plus').PopperEffect;
-        tabindex: string | number;
-        valueOnClear: string | number | boolean | Function;
-        autocomplete: string;
-        validateEvent: boolean;
-        clearable: boolean;
-        fallbackPlacements: Placement[];
-        popperOptions: Partial<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: "plain" | "dark" | "light";
-        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: 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: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        autocomplete: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        automaticDropdown: BooleanConstructor;
-        size: {
-            readonly type: PropType<"" | "default" | "small" | "large">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        effect: {
-            readonly type: 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: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
+        options: {
+            type: PropType<SelectOptions[]>;
+            default: () => never[];
         };
-        popperOptions: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: () => Partial<Options>;
+        collapseTags: {
+            type: BooleanConstructor;
+            default: boolean;
         };
-        remote: BooleanConstructor;
-        loadingText: StringConstructor;
-        noMatchText: StringConstructor;
-        noDataText: StringConstructor;
-        remoteMethod: FunctionConstructor;
-        filterMethod: FunctionConstructor;
-        multiple: BooleanConstructor;
-        multipleLimit: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
+        clearable: {
+            type: BooleanConstructor;
+            default: boolean;
         };
-        placeholder: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        defaultFirstOption: BooleanConstructor;
-        reserveKeyword: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        valueKey: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        collapseTags: BooleanConstructor;
-        collapseTagsTooltip: BooleanConstructor;
-        maxCollapseTags: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        teleported: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: true;
-        };
-        persistent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        clearIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        fitInputWidth: BooleanConstructor;
-        suffixIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        tagType: {
-            default: string;
-            type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
         };
-        tagEffect: {
+        cssStyle: {
+            type: StringConstructor;
             default: string;
-            type: PropType<"plain" | "dark" | "light">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
         };
-        validateEvent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        remoteShowSuffix: BooleanConstructor;
-        showArrow: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        offset: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        placement: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        fallbackPlacements: {
-            readonly type: PropType<Placement[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string[];
-        };
-        tabindex: {
-            readonly type: PropType<string | number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        appendTo: {
-            readonly type: 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;
+    }>,
+    {
+        component: import('vue').Ref<
+            | import('vue').CreateComponentPublicInstanceWithMixins<
+                  Readonly<
+                      import('vue').ExtractPropTypes<{
+                          ariaLabel: StringConstructor;
+                          emptyValues: ArrayConstructor;
+                          valueOnClear: {
+                              readonly type: 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: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: undefined;
+                          };
+                          autocomplete: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          automaticDropdown: BooleanConstructor;
+                          size: {
+                              readonly type: PropType<'' | 'default' | 'small' | 'large'>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          effect: {
+                              readonly type: 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: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          popperOptions: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: () => Partial<Options>;
+                          };
+                          remote: BooleanConstructor;
+                          loadingText: StringConstructor;
+                          noMatchText: StringConstructor;
+                          noDataText: StringConstructor;
+                          remoteMethod: FunctionConstructor;
+                          filterMethod: FunctionConstructor;
+                          multiple: BooleanConstructor;
+                          multipleLimit: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placeholder: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          defaultFirstOption: BooleanConstructor;
+                          reserveKeyword: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          valueKey: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          collapseTags: BooleanConstructor;
+                          collapseTagsTooltip: BooleanConstructor;
+                          maxCollapseTags: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          teleported: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: true;
+                          };
+                          persistent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          clearIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          fitInputWidth: BooleanConstructor;
+                          suffixIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagType: {
+                              default: string;
+                              type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagEffect: {
+                              default: string;
+                              type: PropType<'plain' | 'dark' | 'light'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          validateEvent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          remoteShowSuffix: BooleanConstructor;
+                          showArrow: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          offset: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placement: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          fallbackPlacements: {
+                              readonly type: PropType<Placement[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string[];
+                          };
+                          tabindex: {
+                              readonly type: PropType<string | number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          appendTo: {
+                              readonly type: 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>;
+                          cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
+                          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-es').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<(string | import('vue').Component) | 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,
+                  ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'visible-change' | 'remove-tag' | 'popup-scroll')[],
+                  import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps,
+                  {
+                      disabled: boolean;
+                      offset: number;
+                      multiple: boolean;
+                      loading: boolean;
+                      modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
+                      placement: any;
+                      effect: import('element-plus').PopperEffect;
+                      tabindex: string | number;
+                      valueOnClear: string | number | boolean | Function;
+                      autocomplete: string;
+                      validateEvent: boolean;
+                      clearable: boolean;
+                      fallbackPlacements: Placement[];
+                      popperOptions: Partial<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: 'plain' | 'dark' | 'light';
+                      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: 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: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: undefined;
+                          };
+                          autocomplete: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          automaticDropdown: BooleanConstructor;
+                          size: {
+                              readonly type: PropType<'' | 'default' | 'small' | 'large'>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          effect: {
+                              readonly type: 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: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          popperOptions: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: () => Partial<Options>;
+                          };
+                          remote: BooleanConstructor;
+                          loadingText: StringConstructor;
+                          noMatchText: StringConstructor;
+                          noDataText: StringConstructor;
+                          remoteMethod: FunctionConstructor;
+                          filterMethod: FunctionConstructor;
+                          multiple: BooleanConstructor;
+                          multipleLimit: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placeholder: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          defaultFirstOption: BooleanConstructor;
+                          reserveKeyword: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          valueKey: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          collapseTags: BooleanConstructor;
+                          collapseTagsTooltip: BooleanConstructor;
+                          maxCollapseTags: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          teleported: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: true;
+                          };
+                          persistent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          clearIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          fitInputWidth: BooleanConstructor;
+                          suffixIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagType: {
+                              default: string;
+                              type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagEffect: {
+                              default: string;
+                              type: PropType<'plain' | 'dark' | 'light'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          validateEvent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          remoteShowSuffix: BooleanConstructor;
+                          showArrow: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          offset: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placement: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          fallbackPlacements: {
+                              readonly type: PropType<Placement[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string[];
+                          };
+                          tabindex: {
+                              readonly type: PropType<string | number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          appendTo: {
+                              readonly type: 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>;
+                          cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
+                          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-es').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<(string | import('vue').Component) | 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: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
+                      placement: any;
+                      effect: import('element-plus').PopperEffect;
+                      tabindex: string | number;
+                      valueOnClear: string | number | boolean | Function;
+                      autocomplete: string;
+                      validateEvent: boolean;
+                      clearable: boolean;
+                      fallbackPlacements: Placement[];
+                      popperOptions: Partial<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: 'plain' | 'dark' | 'light';
+                      automaticDropdown: boolean;
+                      allowCreate: boolean;
+                      remote: boolean;
+                      multipleLimit: number;
+                      defaultFirstOption: boolean;
+                      reserveKeyword: boolean;
+                      remoteShowSuffix: boolean;
+                  }
+              >
+            | null,
+            | import('vue').CreateComponentPublicInstanceWithMixins<
+                  Readonly<
+                      import('vue').ExtractPropTypes<{
+                          ariaLabel: StringConstructor;
+                          emptyValues: ArrayConstructor;
+                          valueOnClear: {
+                              readonly type: 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: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: undefined;
+                          };
+                          autocomplete: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          automaticDropdown: BooleanConstructor;
+                          size: {
+                              readonly type: PropType<'' | 'default' | 'small' | 'large'>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          effect: {
+                              readonly type: 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: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          popperOptions: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: () => Partial<Options>;
+                          };
+                          remote: BooleanConstructor;
+                          loadingText: StringConstructor;
+                          noMatchText: StringConstructor;
+                          noDataText: StringConstructor;
+                          remoteMethod: FunctionConstructor;
+                          filterMethod: FunctionConstructor;
+                          multiple: BooleanConstructor;
+                          multipleLimit: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placeholder: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          defaultFirstOption: BooleanConstructor;
+                          reserveKeyword: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          valueKey: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          collapseTags: BooleanConstructor;
+                          collapseTagsTooltip: BooleanConstructor;
+                          maxCollapseTags: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          teleported: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: true;
+                          };
+                          persistent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          clearIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          fitInputWidth: BooleanConstructor;
+                          suffixIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagType: {
+                              default: string;
+                              type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagEffect: {
+                              default: string;
+                              type: PropType<'plain' | 'dark' | 'light'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          validateEvent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          remoteShowSuffix: BooleanConstructor;
+                          showArrow: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          offset: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placement: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          fallbackPlacements: {
+                              readonly type: PropType<Placement[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string[];
+                          };
+                          tabindex: {
+                              readonly type: PropType<string | number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          appendTo: {
+                              readonly type: 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>;
+                          cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
+                          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-es').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<(string | import('vue').Component) | 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,
+                  ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'visible-change' | 'remove-tag' | 'popup-scroll')[],
+                  import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps,
+                  {
+                      disabled: boolean;
+                      offset: number;
+                      multiple: boolean;
+                      loading: boolean;
+                      modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
+                      placement: any;
+                      effect: import('element-plus').PopperEffect;
+                      tabindex: string | number;
+                      valueOnClear: string | number | boolean | Function;
+                      autocomplete: string;
+                      validateEvent: boolean;
+                      clearable: boolean;
+                      fallbackPlacements: Placement[];
+                      popperOptions: Partial<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: 'plain' | 'dark' | 'light';
+                      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: 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: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: undefined;
+                          };
+                          autocomplete: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          automaticDropdown: BooleanConstructor;
+                          size: {
+                              readonly type: PropType<'' | 'default' | 'small' | 'large'>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          effect: {
+                              readonly type: 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: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          popperOptions: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: () => Partial<Options>;
+                          };
+                          remote: BooleanConstructor;
+                          loadingText: StringConstructor;
+                          noMatchText: StringConstructor;
+                          noDataText: StringConstructor;
+                          remoteMethod: FunctionConstructor;
+                          filterMethod: FunctionConstructor;
+                          multiple: BooleanConstructor;
+                          multipleLimit: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placeholder: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          defaultFirstOption: BooleanConstructor;
+                          reserveKeyword: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          valueKey: {
+                              readonly type: PropType<string>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          collapseTags: BooleanConstructor;
+                          collapseTagsTooltip: BooleanConstructor;
+                          maxCollapseTags: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          teleported: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: true;
+                          };
+                          persistent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          clearIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          fitInputWidth: BooleanConstructor;
+                          suffixIcon: {
+                              readonly type: PropType<string | import('vue').Component>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagType: {
+                              default: string;
+                              type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          tagEffect: {
+                              default: string;
+                              type: PropType<'plain' | 'dark' | 'light'>;
+                              required: false;
+                              validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          };
+                          validateEvent: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          remoteShowSuffix: BooleanConstructor;
+                          showArrow: {
+                              readonly type: PropType<boolean>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: boolean;
+                          };
+                          offset: {
+                              readonly type: PropType<number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          placement: {
+                              readonly type: PropType<any>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string;
+                          };
+                          fallbackPlacements: {
+                              readonly type: PropType<Placement[]>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: string[];
+                          };
+                          tabindex: {
+                              readonly type: PropType<string | number>;
+                              readonly required: false;
+                              readonly validator: ((val: unknown) => boolean) | undefined;
+                              __epPropKey: true;
+                          } & {
+                              readonly default: number;
+                          };
+                          appendTo: {
+                              readonly type: 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>;
+                          cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
+                          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-es').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<(string | import('vue').Component) | 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: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
+                      placement: any;
+                      effect: import('element-plus').PopperEffect;
+                      tabindex: string | number;
+                      valueOnClear: string | number | boolean | Function;
+                      autocomplete: string;
+                      validateEvent: boolean;
+                      clearable: boolean;
+                      fallbackPlacements: Placement[];
+                      popperOptions: Partial<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: 'plain' | 'dark' | 'light';
+                      automaticDropdown: boolean;
+                      allowCreate: boolean;
+                      remote: boolean;
+                      multipleLimit: number;
+                      defaultFirstOption: boolean;
+                      reserveKeyword: boolean;
+                      remoteShowSuffix: boolean;
+                  }
+              >
+            | null
+        >;
+    },
+    {},
+    {},
+    {},
+    import('vue').ComponentOptionsMixin,
+    import('vue').ComponentOptionsMixin,
+    {
+        'update:modelValue': (value: any) => any;
+    },
+    string,
+    import('vue').PublicProps,
+    Readonly<
+        import('vue').ExtractPropTypes<{
+            modelValue: {
+                type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
+                default: 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;
+            options: {
+                type: PropType<SelectOptions[]>;
+                default: () => never[];
             };
-            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>;
-            cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
-            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-es').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<(string | import('vue').Component) | 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: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
-        placement: any;
-        effect: import('element-plus').PopperEffect;
-        tabindex: string | number;
-        valueOnClear: string | number | boolean | Function;
-        autocomplete: string;
-        validateEvent: boolean;
-        clearable: boolean;
-        fallbackPlacements: Placement[];
-        popperOptions: Partial<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: "plain" | "dark" | "light";
-        automaticDropdown: boolean;
-        allowCreate: boolean;
-        remote: boolean;
-        multipleLimit: number;
-        defaultFirstOption: boolean;
-        reserveKeyword: boolean;
-        remoteShowSuffix: boolean;
-    }> | null, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-        ariaLabel: StringConstructor;
-        emptyValues: ArrayConstructor;
-        valueOnClear: {
-            readonly type: 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: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        autocomplete: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        automaticDropdown: BooleanConstructor;
-        size: {
-            readonly type: PropType<"" | "default" | "small" | "large">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        effect: {
-            readonly type: 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: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        popperOptions: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: () => Partial<Options>;
-        };
-        remote: BooleanConstructor;
-        loadingText: StringConstructor;
-        noMatchText: StringConstructor;
-        noDataText: StringConstructor;
-        remoteMethod: FunctionConstructor;
-        filterMethod: FunctionConstructor;
-        multiple: BooleanConstructor;
-        multipleLimit: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        placeholder: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        defaultFirstOption: BooleanConstructor;
-        reserveKeyword: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        valueKey: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        collapseTags: BooleanConstructor;
-        collapseTagsTooltip: BooleanConstructor;
-        maxCollapseTags: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        teleported: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: true;
-        };
-        persistent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        clearIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        fitInputWidth: BooleanConstructor;
-        suffixIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        tagType: {
-            default: string;
-            type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        tagEffect: {
-            default: string;
-            type: PropType<"plain" | "dark" | "light">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        validateEvent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        remoteShowSuffix: BooleanConstructor;
-        showArrow: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        offset: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        placement: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        fallbackPlacements: {
-            readonly type: PropType<Placement[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string[];
-        };
-        tabindex: {
-            readonly type: PropType<string | number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        appendTo: {
-            readonly type: 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;
+            collapseTags: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            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;
+            clearable: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            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>;
-            cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
-            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-es').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<(string | import('vue').Component) | 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, ("blur" | "change" | "focus" | "clear" | "update:modelValue" | "visible-change" | "remove-tag" | "popup-scroll")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
-        disabled: boolean;
-        offset: number;
-        multiple: boolean;
-        loading: boolean;
-        modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
-        placement: any;
-        effect: import('element-plus').PopperEffect;
-        tabindex: string | number;
-        valueOnClear: string | number | boolean | Function;
-        autocomplete: string;
-        validateEvent: boolean;
-        clearable: boolean;
-        fallbackPlacements: Placement[];
-        popperOptions: Partial<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: "plain" | "dark" | "light";
-        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: 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: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        autocomplete: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        automaticDropdown: BooleanConstructor;
-        size: {
-            readonly type: PropType<"" | "default" | "small" | "large">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        effect: {
-            readonly type: 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: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        popperOptions: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: () => Partial<Options>;
-        };
-        remote: BooleanConstructor;
-        loadingText: StringConstructor;
-        noMatchText: StringConstructor;
-        noDataText: StringConstructor;
-        remoteMethod: FunctionConstructor;
-        filterMethod: FunctionConstructor;
-        multiple: BooleanConstructor;
-        multipleLimit: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        placeholder: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        defaultFirstOption: BooleanConstructor;
-        reserveKeyword: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        valueKey: {
-            readonly type: PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        collapseTags: BooleanConstructor;
-        collapseTagsTooltip: BooleanConstructor;
-        maxCollapseTags: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        teleported: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: true;
-        };
-        persistent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        clearIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        fitInputWidth: BooleanConstructor;
-        suffixIcon: {
-            readonly type: PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        tagType: {
-            default: string;
-            type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        tagEffect: {
-            default: string;
-            type: PropType<"plain" | "dark" | "light">;
-            required: false;
-            validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        validateEvent: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        remoteShowSuffix: BooleanConstructor;
-        showArrow: {
-            readonly type: PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: boolean;
-        };
-        offset: {
-            readonly type: PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        placement: {
-            readonly type: PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string;
-        };
-        fallbackPlacements: {
-            readonly type: PropType<Placement[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: string[];
-        };
-        tabindex: {
-            readonly type: PropType<string | number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: number;
-        };
-        appendTo: {
-            readonly type: 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;
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            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;
+            cssStyle: {
+                type: StringConstructor;
+                default: 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>;
-            cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
-            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-es').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<(string | import('vue').Component) | 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: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
-        placement: any;
-        effect: import('element-plus').PopperEffect;
-        tabindex: string | number;
-        valueOnClear: string | number | boolean | Function;
-        autocomplete: string;
-        validateEvent: boolean;
+        }>
+    > &
+        Readonly<{
+            'onUpdate:modelValue'?: ((value: any) => any) | undefined;
+        }>,
+    {
+        cssStyle: string;
+        modelValue: string | number | unknown[];
+        options: SelectOptions[];
         clearable: boolean;
-        fallbackPlacements: Placement[];
-        popperOptions: Partial<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: "plain" | "dark" | "light";
-        automaticDropdown: boolean;
-        allowCreate: boolean;
-        remote: boolean;
-        multipleLimit: number;
-        defaultFirstOption: boolean;
-        reserveKeyword: boolean;
-        remoteShowSuffix: boolean;
-    }> | null>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: any) => any;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    modelValue: {
-        type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
-        default: string;
-    };
-    options: {
-        type: PropType<SelectOptions[]>;
-        default: () => never[];
-    };
-    collapseTags: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    clearable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    multiple: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{
-    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
-}>, {
-    modelValue: string | number | unknown[];
-    options: SelectOptions[];
-    clearable: boolean;
-    collapseTags: boolean;
-    multiple: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    componentRef: unknown;
-}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+        multiple: boolean;
+    },
+    {},
+    {},
+    {},
+    string,
+    import('vue').ComponentProvideOptions,
+    true,
+    {
+        componentRef: unknown;
+    },
+    any
+>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult['slots']>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {