import type { TreeNodeData, TreeKey } from 'element-plus/es/components/tree/src/tree.type';
import type Node from 'element-plus/es/components/tree/src/model/node';
import type { SelectTreeBaseModelValue } from './selectTree';
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[]) | (((new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[])) | null)[], unknown, unknown, string, boolean>;
    bindObject: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    multiple: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    filterable: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    collapseTags: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    clearable: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    lazy: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    load: {
        readonly type: import("vue").PropType<import("element-plus").LoadFunction>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    checkStrictly: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    filterChildWhenSelectAll: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    placeholder: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    label: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown, string, boolean>;
    valueKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
    childrenKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
    disabled: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown, string, boolean>;
    isLeaf: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown, string, boolean>;
    data: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData) | (((new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
    treeProps: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").TreeComponentProps>) | (() => Partial<import("element-plus").TreeComponentProps>) | (((new (...args: any[]) => Partial<import("element-plus").TreeComponentProps>) | (() => Partial<import("element-plus").TreeComponentProps>)) | null)[], unknown, unknown, () => {}, boolean>;
    selectProps: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").SelectProps>) | (() => Partial<import("element-plus").SelectProps>) | (((new (...args: any[]) => Partial<import("element-plus").SelectProps>) | (() => Partial<import("element-plus").SelectProps>)) | null)[], unknown, unknown, () => {}, boolean>;
}>, {
    elSelectCtx: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        ariaLabel: StringConstructor;
        emptyValues: ArrayConstructor;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
        name: StringConstructor;
        id: StringConstructor;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown, undefined, boolean>;
        autocomplete: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        automaticDropdown: BooleanConstructor;
        size: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        effect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown, string, boolean>;
        disabled: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
        clearable: BooleanConstructor;
        filterable: BooleanConstructor;
        allowCreate: BooleanConstructor;
        loading: BooleanConstructor;
        popperClass: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        popperStyle: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties) | (((new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        popperOptions: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => Partial<import("element-plus").Options>, boolean>;
        remote: BooleanConstructor;
        debounce: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        loadingText: StringConstructor;
        noMatchText: StringConstructor;
        noDataText: StringConstructor;
        remoteMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        filterMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        multiple: BooleanConstructor;
        multipleLimit: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placeholder: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        defaultFirstOption: BooleanConstructor;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        valueKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        collapseTags: BooleanConstructor;
        collapseTagsTooltip: BooleanConstructor;
        tagTooltip: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps) | (((new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
        maxCollapseTags: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        fitInputWidth: BooleanConstructor;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        tagType: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        tagEffect: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        remoteShowSuffix: BooleanConstructor;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        offset: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placement: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, string, boolean>;
        fallbackPlacements: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, string[], boolean>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
        appendTo: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        options: {
            readonly type: import("vue").PropType<Record<string, any>[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (((new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props)) | null)[], unknown, unknown, () => Required<import("element-plus/es/components/select-v2/src/useProps.mjs").Props>, boolean>;
    }>> & Readonly<{
        onClear?: (() => any) | undefined;
        "onUpdate:modelValue"?: ((val: any) => any) | undefined;
        onChange?: ((val: any) => any) | undefined;
        onBlur?: ((evt: FocusEvent) => any) | undefined;
        onFocus?: ((evt: FocusEvent) => any) | undefined;
        "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
        "onVisible-change"?: ((visible: boolean) => any) | undefined;
        "onRemove-tag"?: ((val: unknown) => any) | undefined;
        "onPopup-scroll"?: ((args_0: {
            scrollTop: number;
            scrollLeft: number;
        }) => any) | undefined;
    }>, {
        modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
        selectedLabel: import("vue").ComputedRef<string | string[]>;
        calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        inputStyle: import("vue").ComputedRef<{
            minWidth: string;
        }>;
        getLabel: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getValue: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptions: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getDisabled: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptionProps: (option: Record<string, any>) => {
            label: any;
            value: any;
            disabled: any;
        };
        inputId: import("vue").Ref<string | undefined, string | undefined>;
        contentId: import("vue").Ref<string, 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<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            cachedOptions: Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            optionValues: import("element-plus/es/components/select/src/type.mjs").OptionValue[];
            selected: {
                index: number;
                value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
                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, boolean>;
        expanded: import("vue").Ref<boolean, boolean>;
        optionsArray: import("vue").ComputedRef<import("element-plus").SelectOptionProxy[]>;
        hoverOption: import("vue").Ref<any, any>;
        selectSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
        filteredOptionsCount: import("vue").ComputedRef<number>;
        updateTooltip: () => void;
        updateTagTooltip: () => void;
        debouncedOnInputChange: import("@vueuse/core").UseDebounceFnReturn<() => void>;
        onInput: (event: Event) => void;
        deletePrevTag: (e: KeyboardEvent) => void;
        deleteTag: (event: MouseEvent, tag: 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/es/components/select/src/type.mjs").SelectStates["selected"]) => void;
        hasModelValue: import("vue").ComputedRef<boolean>;
        shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
        currentPlaceholder: import("vue").ComputedRef<string>;
        mouseEnterEventName: string | null;
        needStatusIcon: import("vue").ComputedRef<boolean>;
        showClearBtn: import("vue").ComputedRef<boolean>;
        iconComponent: import("vue").ComputedRef<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
        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;
        handleKeydown: (e: KeyboardEvent) => void;
        onOptionCreate: (vm: import("element-plus").SelectOptionProxy) => void;
        onOptionDestroy: (key: import("element-plus/es/components/select/src/type.mjs").OptionValue, vm: import("element-plus").SelectOptionProxy) => void;
        handleMenuEnter: () => void;
        focus: () => void;
        blur: () => void;
        handleClearClick: (event: Event) => void;
        handleClickOutside: (event: Event) => void;
        handleEsc: () => void;
        toggleMenu: (event?: Event) => void;
        selectOption: () => void;
        getValueKey: (item: import("element-plus").SelectOptionProxy | import("element-plus/es/components/select/src/type.mjs").SelectStates["selected"][0]) => any;
        navigateOptions: (direction: "prev" | "next") => void;
        dropdownMenuVisible: import("vue").WritableComputedRef<boolean, boolean>;
        showTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        collapseTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        popupScroll: (data: {
            scrollTop: number;
            scrollLeft: number;
        }) => void;
        getOption: (value: import("element-plus/es/components/select/src/type.mjs").OptionValue) => {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: any;
        } | {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: string | number | boolean;
            readonly isDisabled: boolean;
        };
        endReached: (direction: import("element-plus").ScrollbarDirection) => 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, HTMLInputElement | undefined>;
        tooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        tagTooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        prefixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        suffixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        selectRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        wrapperRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        selectionRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        scrollbarRef: import("vue").Ref<import("element-plus").ScrollbarInstance | undefined, import("element-plus").ScrollbarInstance | undefined>;
        menuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        tagMenuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        collapseItemRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        "update:modelValue": (val: import("element-plus").SelectProps["modelValue"] | any) => boolean;
        change: (val: import("element-plus").SelectProps["modelValue"] | any) => boolean;
        'popup-scroll': ({ scrollTop, scrollLeft }: {
            scrollTop: number;
            scrollLeft: number;
        }) => boolean;
        'end-reached': (direction: import("element-plus").ScrollbarDirection) => boolean;
        'remove-tag': (val: unknown) => boolean;
        'visible-change': (visible: boolean) => boolean;
        focus: (evt: FocusEvent) => boolean;
        blur: (evt: FocusEvent) => boolean;
        clear: () => boolean;
    }, import("vue").PublicProps, {
        props: import("element-plus/es/components/select-v2/src/useProps.mjs").Props;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown>;
        loading: boolean;
        disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>;
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        multiple: boolean;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        popperClass: string;
        effect: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown>;
        fallbackPlacements: import("element-plus").Placement[];
        offset: number;
        placement: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
        popperOptions: Partial<import("element-plus").Options>;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        autocomplete: string;
        clearable: boolean;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        valueKey: string;
        debounce: number;
        fitInputWidth: boolean;
        filterable: boolean;
        collapseTags: boolean;
        maxCollapseTags: number;
        collapseTagsTooltip: boolean;
        tagType: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>;
        tagEffect: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>;
        automaticDropdown: boolean;
        allowCreate: boolean;
        remote: boolean;
        multipleLimit: number;
        defaultFirstOption: boolean;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tagTooltip: import("element-plus").TagTooltipProps;
        remoteShowSuffix: boolean;
    }, true, {}, {}, {
        ElSelectMenu: import("vue").DefineComponent<{}, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            minWidth: import("vue").Ref<string, string>;
            popperClass: import("vue").ComputedRef<string>;
            isMultiple: import("vue").ComputedRef<boolean>;
            isFitInputWidth: import("vue").ComputedRef<boolean>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElOption: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            value: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: true;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            label: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            created: BooleanConstructor;
            disabled: BooleanConstructor;
        }>, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            id: import("vue").Ref<string, string>;
            containerKls: import("vue").ComputedRef<string[]>;
            currentLabel: import("vue").ComputedRef<boolean | import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
            itemSelected: import("vue").ComputedRef<boolean>;
            isDisabled: import("vue").ComputedRef<boolean>;
            select: import("element-plus").SelectContext;
            visible: import("vue").Ref<boolean, boolean>;
            hover: import("vue").Ref<boolean, boolean>;
            states: {
                index: number;
                groupDisabled: boolean;
                visible: boolean;
                hover: boolean;
            };
            mouseMoveEventName: "mousemove" | null;
            hoverItem: () => void;
            handleMousedown: (event: MouseEvent) => void;
            updateOption: (query: string) => void;
            selectOptionClick: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            value: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: true;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            label: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            created: BooleanConstructor;
            disabled: BooleanConstructor;
        }>> & Readonly<{}>, {
            disabled: boolean;
            created: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElOptions: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElOptionGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            label: StringConstructor;
            disabled: BooleanConstructor;
        }>, {
            groupRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            visible: import("vue").ComputedRef<boolean>;
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            label: StringConstructor;
            disabled: BooleanConstructor;
        }>> & Readonly<{}>, {
            disabled: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElTag: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").TagProps> & Readonly<{
                onClose?: ((evt: MouseEvent) => any) | undefined;
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                close: (evt: MouseEvent) => void;
                click: (evt: MouseEvent) => void;
            }, import("vue").PublicProps, {
                type: "primary" | "success" | "info" | "warning" | "danger";
                effect: "dark" | "light" | "plain";
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").TagProps> & Readonly<{
                onClose?: ((evt: MouseEvent) => any) | undefined;
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }>, {}, {}, {}, {}, {
                type: "primary" | "success" | "info" | "warning" | "danger";
                effect: "dark" | "light" | "plain";
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").TagProps> & Readonly<{
            onClose?: ((evt: MouseEvent) => any) | undefined;
            onClick?: ((evt: MouseEvent) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            close: (evt: MouseEvent) => void;
            click: (evt: MouseEvent) => void;
        }, string, {
            type: "primary" | "success" | "info" | "warning" | "danger";
            effect: "dark" | "light" | "plain";
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            } & {
                default?: (props: {}) => any;
            };
        })>;
        ElScrollbar: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
                onScroll?: ((args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => any) | undefined;
                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
            }>, {
                wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
                update: () => void;
                scrollTo: {
                    (xCord: number, yCord?: number): void;
                    (options: ScrollToOptions): void;
                };
                setScrollTop: (value: number) => void;
                setScrollLeft: (value: number) => void;
                handleScroll: () => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                scroll: (args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => void;
                "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
            }, import("vue").PublicProps, {
                tag: keyof HTMLElementTagNameMap | (string & {});
                tabindex: number | string;
                height: number | string;
                maxHeight: number | string;
                distance: number;
                wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                wrapClass: string | string[];
                viewClass: string | string[];
                viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                minSize: number;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").ScrollbarProps> & Readonly<{
                onScroll?: ((args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => any) | undefined;
                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
            }>, {
                wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
                update: () => void;
                scrollTo: {
                    (xCord: number, yCord?: number): void;
                    (options: ScrollToOptions): void;
                };
                setScrollTop: (value: number) => void;
                setScrollLeft: (value: number) => void;
                handleScroll: () => void;
            }, {}, {}, {}, {
                tag: keyof HTMLElementTagNameMap | (string & {});
                tabindex: number | string;
                height: number | string;
                maxHeight: number | string;
                distance: number;
                wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                wrapClass: string | string[];
                viewClass: string | string[];
                viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                minSize: number;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
            onScroll?: ((args_0: {
                scrollTop: number;
                scrollLeft: number;
            }) => any) | undefined;
            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
        }>, {
            wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            update: () => void;
            scrollTo: {
                (xCord: number, yCord?: number): void;
                (options: ScrollToOptions): void;
            };
            setScrollTop: (value: number) => void;
            setScrollLeft: (value: number) => void;
            handleScroll: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            scroll: (args_0: {
                scrollTop: number;
                scrollLeft: number;
            }) => void;
            "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
        }, string, {
            tag: keyof HTMLElementTagNameMap | (string & {});
            tabindex: number | string;
            height: number | string;
            maxHeight: number | string;
            distance: number;
            wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            wrapClass: string | string[];
            viewClass: string | string[];
            viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            minSize: number;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            };
        })>;
        ElTooltip: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").UseTooltipProps> & Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
                onHide?: ((...args: any[]) => any) | undefined;
                onShow?: ((...args: any[]) => any) | undefined;
                onOpen?: ((...args: any[]) => any) | undefined;
                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                "onBefore-show"?: ((...args: any[]) => any) | undefined;
                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
            }>, {
                popperRef: import("vue").Ref<import("element-plus").PopperInstance | undefined, import("element-plus").PopperInstance | undefined>;
                contentRef: import("vue").Ref<import("element-plus").TooltipContentInstance | undefined, import("element-plus").TooltipContentInstance | undefined>;
                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                updatePopper: () => void;
                onOpen: (event?: Event, delay?: number) => void;
                onClose: (event?: Event, delay?: number) => void;
                hide: (event?: Event) => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                close: (...args: any[]) => void;
                hide: (...args: any[]) => void;
                show: (...args: any[]) => void;
                open: (...args: any[]) => void;
                "update:visible": (...args: any[]) => void;
                "before-show": (...args: any[]) => void;
                "before-hide": (...args: any[]) => void;
            }, import("vue").PublicProps, {
                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                role: "group" | "dialog" | "menu" | "tooltip" | "tree" | "listbox" | "grid" | "navigation";
                visible: boolean | null;
                content: string;
                teleported: boolean;
                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                effect: import("element-plus").PopperEffect;
                enterable: boolean;
                pure: boolean;
                focusOnShow: boolean;
                trapping: boolean;
                stopPopperMouseEvent: boolean;
                virtualTriggering: boolean;
                loop: boolean;
                boundariesPadding: number;
                gpuAcceleration: boolean;
                offset: number;
                placement: import("element-plus").Placement;
                popperOptions: Partial<import("element-plus").Options>;
                strategy: "absolute" | "fixed";
                arrowOffset: number;
                showArrow: boolean;
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                trigger: import("element-plus/es/utils/typescript.mjs").Arrayable<import("element-plus").TooltipTriggerType>;
                triggerKeys: string[];
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").UseTooltipProps> & Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
                onHide?: ((...args: any[]) => any) | undefined;
                onShow?: ((...args: any[]) => any) | undefined;
                onOpen?: ((...args: any[]) => any) | undefined;
                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                "onBefore-show"?: ((...args: any[]) => any) | undefined;
                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
            }>, {
                popperRef: import("vue").Ref<import("element-plus").PopperInstance | undefined, import("element-plus").PopperInstance | undefined>;
                contentRef: import("vue").Ref<import("element-plus").TooltipContentInstance | undefined, import("element-plus").TooltipContentInstance | undefined>;
                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                updatePopper: () => void;
                onOpen: (event?: Event, delay?: number) => void;
                onClose: (event?: Event, delay?: number) => void;
                hide: (event?: Event) => void;
            }, {}, {}, {}, {
                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                role: "group" | "dialog" | "menu" | "tooltip" | "tree" | "listbox" | "grid" | "navigation";
                visible: boolean | null;
                content: string;
                teleported: boolean;
                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                effect: import("element-plus").PopperEffect;
                enterable: boolean;
                pure: boolean;
                focusOnShow: boolean;
                trapping: boolean;
                stopPopperMouseEvent: boolean;
                virtualTriggering: boolean;
                loop: boolean;
                boundariesPadding: number;
                gpuAcceleration: boolean;
                offset: number;
                placement: import("element-plus").Placement;
                popperOptions: Partial<import("element-plus").Options>;
                strategy: "absolute" | "fixed";
                arrowOffset: number;
                showArrow: boolean;
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                trigger: import("element-plus/es/utils/typescript.mjs").Arrayable<import("element-plus").TooltipTriggerType>;
                triggerKeys: string[];
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").UseTooltipProps> & Readonly<{
            onClose?: ((...args: any[]) => any) | undefined;
            onHide?: ((...args: any[]) => any) | undefined;
            onShow?: ((...args: any[]) => any) | undefined;
            onOpen?: ((...args: any[]) => any) | undefined;
            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
            "onBefore-show"?: ((...args: any[]) => any) | undefined;
            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
        }>, {
            popperRef: import("vue").Ref<import("element-plus").PopperInstance | undefined, import("element-plus").PopperInstance | undefined>;
            contentRef: import("vue").Ref<import("element-plus").TooltipContentInstance | undefined, import("element-plus").TooltipContentInstance | undefined>;
            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
            updatePopper: () => void;
            onOpen: (event?: Event, delay?: number) => void;
            onClose: (event?: Event, delay?: number) => void;
            hide: (event?: Event) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            close: (...args: any[]) => void;
            hide: (...args: any[]) => void;
            show: (...args: any[]) => void;
            open: (...args: any[]) => void;
            "update:visible": (...args: any[]) => void;
            "before-show": (...args: any[]) => void;
            "before-hide": (...args: any[]) => void;
        }, string, {
            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            role: "group" | "dialog" | "menu" | "tooltip" | "tree" | "listbox" | "grid" | "navigation";
            visible: boolean | null;
            content: string;
            teleported: boolean;
            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            effect: import("element-plus").PopperEffect;
            enterable: boolean;
            pure: boolean;
            focusOnShow: boolean;
            trapping: boolean;
            stopPopperMouseEvent: boolean;
            virtualTriggering: boolean;
            loop: boolean;
            boundariesPadding: number;
            gpuAcceleration: boolean;
            offset: number;
            placement: import("element-plus").Placement;
            popperOptions: Partial<import("element-plus").Options>;
            strategy: "absolute" | "fixed";
            arrowOffset: number;
            showArrow: boolean;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            trigger: import("element-plus/es/utils/typescript.mjs").Arrayable<import("element-plus").TooltipTriggerType>;
            triggerKeys: string[];
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            } & {
                content?: (props: {}) => any;
            };
        })>;
        ElIcon: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            };
        })>;
    } & import("vue").GlobalComponents, {
        ClickOutside: import("vue").ObjectDirective<HTMLElement, any, string, any>;
    } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        ariaLabel: StringConstructor;
        emptyValues: ArrayConstructor;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
        name: StringConstructor;
        id: StringConstructor;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown, undefined, boolean>;
        autocomplete: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        automaticDropdown: BooleanConstructor;
        size: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        effect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown, string, boolean>;
        disabled: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
        clearable: BooleanConstructor;
        filterable: BooleanConstructor;
        allowCreate: BooleanConstructor;
        loading: BooleanConstructor;
        popperClass: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        popperStyle: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties) | (((new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        popperOptions: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => Partial<import("element-plus").Options>, boolean>;
        remote: BooleanConstructor;
        debounce: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        loadingText: StringConstructor;
        noMatchText: StringConstructor;
        noDataText: StringConstructor;
        remoteMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        filterMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        multiple: BooleanConstructor;
        multipleLimit: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placeholder: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        defaultFirstOption: BooleanConstructor;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        valueKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        collapseTags: BooleanConstructor;
        collapseTagsTooltip: BooleanConstructor;
        tagTooltip: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps) | (((new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
        maxCollapseTags: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        fitInputWidth: BooleanConstructor;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        tagType: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        tagEffect: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        remoteShowSuffix: BooleanConstructor;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        offset: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placement: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, string, boolean>;
        fallbackPlacements: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, string[], boolean>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
        appendTo: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        options: {
            readonly type: import("vue").PropType<Record<string, any>[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (((new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props)) | null)[], unknown, unknown, () => Required<import("element-plus/es/components/select-v2/src/useProps.mjs").Props>, boolean>;
    }>> & Readonly<{
        onClear?: (() => any) | undefined;
        "onUpdate:modelValue"?: ((val: any) => any) | undefined;
        onChange?: ((val: any) => any) | undefined;
        onBlur?: ((evt: FocusEvent) => any) | undefined;
        onFocus?: ((evt: FocusEvent) => any) | undefined;
        "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
        "onVisible-change"?: ((visible: boolean) => any) | undefined;
        "onRemove-tag"?: ((val: unknown) => any) | undefined;
        "onPopup-scroll"?: ((args_0: {
            scrollTop: number;
            scrollLeft: number;
        }) => any) | undefined;
    }>, {
        modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
        selectedLabel: import("vue").ComputedRef<string | string[]>;
        calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        inputStyle: import("vue").ComputedRef<{
            minWidth: string;
        }>;
        getLabel: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getValue: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptions: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getDisabled: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptionProps: (option: Record<string, any>) => {
            label: any;
            value: any;
            disabled: any;
        };
        inputId: import("vue").Ref<string | undefined, string | undefined>;
        contentId: import("vue").Ref<string, 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<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            cachedOptions: Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            optionValues: import("element-plus/es/components/select/src/type.mjs").OptionValue[];
            selected: {
                index: number;
                value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
                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, boolean>;
        expanded: import("vue").Ref<boolean, boolean>;
        optionsArray: import("vue").ComputedRef<import("element-plus").SelectOptionProxy[]>;
        hoverOption: import("vue").Ref<any, any>;
        selectSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
        filteredOptionsCount: import("vue").ComputedRef<number>;
        updateTooltip: () => void;
        updateTagTooltip: () => void;
        debouncedOnInputChange: import("@vueuse/core").UseDebounceFnReturn<() => void>;
        onInput: (event: Event) => void;
        deletePrevTag: (e: KeyboardEvent) => void;
        deleteTag: (event: MouseEvent, tag: 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/es/components/select/src/type.mjs").SelectStates["selected"]) => void;
        hasModelValue: import("vue").ComputedRef<boolean>;
        shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
        currentPlaceholder: import("vue").ComputedRef<string>;
        mouseEnterEventName: string | null;
        needStatusIcon: import("vue").ComputedRef<boolean>;
        showClearBtn: import("vue").ComputedRef<boolean>;
        iconComponent: import("vue").ComputedRef<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
        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;
        handleKeydown: (e: KeyboardEvent) => void;
        onOptionCreate: (vm: import("element-plus").SelectOptionProxy) => void;
        onOptionDestroy: (key: import("element-plus/es/components/select/src/type.mjs").OptionValue, vm: import("element-plus").SelectOptionProxy) => void;
        handleMenuEnter: () => void;
        focus: () => void;
        blur: () => void;
        handleClearClick: (event: Event) => void;
        handleClickOutside: (event: Event) => void;
        handleEsc: () => void;
        toggleMenu: (event?: Event) => void;
        selectOption: () => void;
        getValueKey: (item: import("element-plus").SelectOptionProxy | import("element-plus/es/components/select/src/type.mjs").SelectStates["selected"][0]) => any;
        navigateOptions: (direction: "prev" | "next") => void;
        dropdownMenuVisible: import("vue").WritableComputedRef<boolean, boolean>;
        showTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        collapseTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        popupScroll: (data: {
            scrollTop: number;
            scrollLeft: number;
        }) => void;
        getOption: (value: import("element-plus/es/components/select/src/type.mjs").OptionValue) => {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: any;
        } | {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: string | number | boolean;
            readonly isDisabled: boolean;
        };
        endReached: (direction: import("element-plus").ScrollbarDirection) => 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, HTMLInputElement | undefined>;
        tooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        tagTooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        prefixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        suffixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        selectRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        wrapperRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        selectionRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        scrollbarRef: import("vue").Ref<import("element-plus").ScrollbarInstance | undefined, import("element-plus").ScrollbarInstance | undefined>;
        menuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        tagMenuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        collapseItemRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
    }, {}, {}, {}, {
        props: import("element-plus/es/components/select-v2/src/useProps.mjs").Props;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown>;
        loading: boolean;
        disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>;
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        multiple: boolean;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        popperClass: string;
        effect: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown>;
        fallbackPlacements: import("element-plus").Placement[];
        offset: number;
        placement: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
        popperOptions: Partial<import("element-plus").Options>;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        autocomplete: string;
        clearable: boolean;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        valueKey: string;
        debounce: number;
        fitInputWidth: boolean;
        filterable: boolean;
        collapseTags: boolean;
        maxCollapseTags: number;
        collapseTagsTooltip: boolean;
        tagType: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>;
        tagEffect: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>;
        automaticDropdown: boolean;
        allowCreate: boolean;
        remote: boolean;
        multipleLimit: number;
        defaultFirstOption: boolean;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tagTooltip: import("element-plus").TagTooltipProps;
        remoteShowSuffix: boolean;
    }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        ariaLabel: StringConstructor;
        emptyValues: ArrayConstructor;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
        name: StringConstructor;
        id: StringConstructor;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown, undefined, boolean>;
        autocomplete: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        automaticDropdown: BooleanConstructor;
        size: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        effect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown, string, boolean>;
        disabled: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
        clearable: BooleanConstructor;
        filterable: BooleanConstructor;
        allowCreate: BooleanConstructor;
        loading: BooleanConstructor;
        popperClass: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        popperStyle: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties) | (((new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        popperOptions: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => Partial<import("element-plus").Options>, boolean>;
        remote: BooleanConstructor;
        debounce: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        loadingText: StringConstructor;
        noMatchText: StringConstructor;
        noDataText: StringConstructor;
        remoteMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        filterMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        multiple: BooleanConstructor;
        multipleLimit: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placeholder: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        defaultFirstOption: BooleanConstructor;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        valueKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        collapseTags: BooleanConstructor;
        collapseTagsTooltip: BooleanConstructor;
        tagTooltip: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps) | (((new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
        maxCollapseTags: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        fitInputWidth: BooleanConstructor;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        tagType: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        tagEffect: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        remoteShowSuffix: BooleanConstructor;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        offset: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placement: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, string, boolean>;
        fallbackPlacements: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, string[], boolean>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
        appendTo: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        options: {
            readonly type: import("vue").PropType<Record<string, any>[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (((new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props)) | null)[], unknown, unknown, () => Required<import("element-plus/es/components/select-v2/src/useProps.mjs").Props>, boolean>;
    }>> & Readonly<{
        onClear?: (() => any) | undefined;
        "onUpdate:modelValue"?: ((val: any) => any) | undefined;
        onChange?: ((val: any) => any) | undefined;
        onBlur?: ((evt: FocusEvent) => any) | undefined;
        onFocus?: ((evt: FocusEvent) => any) | undefined;
        "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
        "onVisible-change"?: ((visible: boolean) => any) | undefined;
        "onRemove-tag"?: ((val: unknown) => any) | undefined;
        "onPopup-scroll"?: ((args_0: {
            scrollTop: number;
            scrollLeft: number;
        }) => any) | undefined;
    }>, {
        modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
        selectedLabel: import("vue").ComputedRef<string | string[]>;
        calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        inputStyle: import("vue").ComputedRef<{
            minWidth: string;
        }>;
        getLabel: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getValue: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptions: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getDisabled: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptionProps: (option: Record<string, any>) => {
            label: any;
            value: any;
            disabled: any;
        };
        inputId: import("vue").Ref<string | undefined, string | undefined>;
        contentId: import("vue").Ref<string, 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<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            cachedOptions: Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            optionValues: import("element-plus/es/components/select/src/type.mjs").OptionValue[];
            selected: {
                index: number;
                value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
                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, boolean>;
        expanded: import("vue").Ref<boolean, boolean>;
        optionsArray: import("vue").ComputedRef<import("element-plus").SelectOptionProxy[]>;
        hoverOption: import("vue").Ref<any, any>;
        selectSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
        filteredOptionsCount: import("vue").ComputedRef<number>;
        updateTooltip: () => void;
        updateTagTooltip: () => void;
        debouncedOnInputChange: import("@vueuse/core").UseDebounceFnReturn<() => void>;
        onInput: (event: Event) => void;
        deletePrevTag: (e: KeyboardEvent) => void;
        deleteTag: (event: MouseEvent, tag: 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/es/components/select/src/type.mjs").SelectStates["selected"]) => void;
        hasModelValue: import("vue").ComputedRef<boolean>;
        shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
        currentPlaceholder: import("vue").ComputedRef<string>;
        mouseEnterEventName: string | null;
        needStatusIcon: import("vue").ComputedRef<boolean>;
        showClearBtn: import("vue").ComputedRef<boolean>;
        iconComponent: import("vue").ComputedRef<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
        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;
        handleKeydown: (e: KeyboardEvent) => void;
        onOptionCreate: (vm: import("element-plus").SelectOptionProxy) => void;
        onOptionDestroy: (key: import("element-plus/es/components/select/src/type.mjs").OptionValue, vm: import("element-plus").SelectOptionProxy) => void;
        handleMenuEnter: () => void;
        focus: () => void;
        blur: () => void;
        handleClearClick: (event: Event) => void;
        handleClickOutside: (event: Event) => void;
        handleEsc: () => void;
        toggleMenu: (event?: Event) => void;
        selectOption: () => void;
        getValueKey: (item: import("element-plus").SelectOptionProxy | import("element-plus/es/components/select/src/type.mjs").SelectStates["selected"][0]) => any;
        navigateOptions: (direction: "prev" | "next") => void;
        dropdownMenuVisible: import("vue").WritableComputedRef<boolean, boolean>;
        showTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        collapseTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        popupScroll: (data: {
            scrollTop: number;
            scrollLeft: number;
        }) => void;
        getOption: (value: import("element-plus/es/components/select/src/type.mjs").OptionValue) => {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: any;
        } | {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: string | number | boolean;
            readonly isDisabled: boolean;
        };
        endReached: (direction: import("element-plus").ScrollbarDirection) => 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, HTMLInputElement | undefined>;
        tooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        tagTooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        prefixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        suffixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        selectRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        wrapperRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        selectionRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        scrollbarRef: import("vue").Ref<import("element-plus").ScrollbarInstance | undefined, import("element-plus").ScrollbarInstance | undefined>;
        menuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        tagMenuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        collapseItemRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        "update:modelValue": (val: import("element-plus").SelectProps["modelValue"] | any) => boolean;
        change: (val: import("element-plus").SelectProps["modelValue"] | any) => boolean;
        'popup-scroll': ({ scrollTop, scrollLeft }: {
            scrollTop: number;
            scrollLeft: number;
        }) => boolean;
        'end-reached': (direction: import("element-plus").ScrollbarDirection) => boolean;
        'remove-tag': (val: unknown) => boolean;
        'visible-change': (visible: boolean) => boolean;
        focus: (evt: FocusEvent) => boolean;
        blur: (evt: FocusEvent) => boolean;
        clear: () => boolean;
    }, import("vue").PublicProps, {
        props: import("element-plus/es/components/select-v2/src/useProps.mjs").Props;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown>;
        loading: boolean;
        disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>;
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        multiple: boolean;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        popperClass: string;
        effect: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown>;
        fallbackPlacements: import("element-plus").Placement[];
        offset: number;
        placement: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
        popperOptions: Partial<import("element-plus").Options>;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        autocomplete: string;
        clearable: boolean;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        valueKey: string;
        debounce: number;
        fitInputWidth: boolean;
        filterable: boolean;
        collapseTags: boolean;
        maxCollapseTags: number;
        collapseTagsTooltip: boolean;
        tagType: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>;
        tagEffect: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>;
        automaticDropdown: boolean;
        allowCreate: boolean;
        remote: boolean;
        multipleLimit: number;
        defaultFirstOption: boolean;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tagTooltip: import("element-plus").TagTooltipProps;
        remoteShowSuffix: boolean;
    }, true, {}, {}, {
        ElSelectMenu: import("vue").DefineComponent<{}, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            minWidth: import("vue").Ref<string, string>;
            popperClass: import("vue").ComputedRef<string>;
            isMultiple: import("vue").ComputedRef<boolean>;
            isFitInputWidth: import("vue").ComputedRef<boolean>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElOption: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            value: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: true;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            label: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            created: BooleanConstructor;
            disabled: BooleanConstructor;
        }>, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            id: import("vue").Ref<string, string>;
            containerKls: import("vue").ComputedRef<string[]>;
            currentLabel: import("vue").ComputedRef<boolean | import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
            itemSelected: import("vue").ComputedRef<boolean>;
            isDisabled: import("vue").ComputedRef<boolean>;
            select: import("element-plus").SelectContext;
            visible: import("vue").Ref<boolean, boolean>;
            hover: import("vue").Ref<boolean, boolean>;
            states: {
                index: number;
                groupDisabled: boolean;
                visible: boolean;
                hover: boolean;
            };
            mouseMoveEventName: "mousemove" | null;
            hoverItem: () => void;
            handleMousedown: (event: MouseEvent) => void;
            updateOption: (query: string) => void;
            selectOptionClick: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            value: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: true;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            label: {
                readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            created: BooleanConstructor;
            disabled: BooleanConstructor;
        }>> & Readonly<{}>, {
            disabled: boolean;
            created: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElOptions: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElOptionGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            label: StringConstructor;
            disabled: BooleanConstructor;
        }>, {
            groupRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            visible: import("vue").ComputedRef<boolean>;
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            label: StringConstructor;
            disabled: BooleanConstructor;
        }>> & Readonly<{}>, {
            disabled: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ElTag: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").TagProps> & Readonly<{
                onClose?: ((evt: MouseEvent) => any) | undefined;
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                close: (evt: MouseEvent) => void;
                click: (evt: MouseEvent) => void;
            }, import("vue").PublicProps, {
                type: "primary" | "success" | "info" | "warning" | "danger";
                effect: "dark" | "light" | "plain";
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").TagProps> & Readonly<{
                onClose?: ((evt: MouseEvent) => any) | undefined;
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }>, {}, {}, {}, {}, {
                type: "primary" | "success" | "info" | "warning" | "danger";
                effect: "dark" | "light" | "plain";
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").TagProps> & Readonly<{
            onClose?: ((evt: MouseEvent) => any) | undefined;
            onClick?: ((evt: MouseEvent) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            close: (evt: MouseEvent) => void;
            click: (evt: MouseEvent) => void;
        }, string, {
            type: "primary" | "success" | "info" | "warning" | "danger";
            effect: "dark" | "light" | "plain";
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            } & {
                default?: (props: {}) => any;
            };
        })>;
        ElScrollbar: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
                onScroll?: ((args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => any) | undefined;
                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
            }>, {
                wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
                update: () => void;
                scrollTo: {
                    (xCord: number, yCord?: number): void;
                    (options: ScrollToOptions): void;
                };
                setScrollTop: (value: number) => void;
                setScrollLeft: (value: number) => void;
                handleScroll: () => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                scroll: (args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => void;
                "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
            }, import("vue").PublicProps, {
                tag: keyof HTMLElementTagNameMap | (string & {});
                tabindex: number | string;
                height: number | string;
                maxHeight: number | string;
                distance: number;
                wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                wrapClass: string | string[];
                viewClass: string | string[];
                viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                minSize: number;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").ScrollbarProps> & Readonly<{
                onScroll?: ((args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => any) | undefined;
                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
            }>, {
                wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
                update: () => void;
                scrollTo: {
                    (xCord: number, yCord?: number): void;
                    (options: ScrollToOptions): void;
                };
                setScrollTop: (value: number) => void;
                setScrollLeft: (value: number) => void;
                handleScroll: () => void;
            }, {}, {}, {}, {
                tag: keyof HTMLElementTagNameMap | (string & {});
                tabindex: number | string;
                height: number | string;
                maxHeight: number | string;
                distance: number;
                wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                wrapClass: string | string[];
                viewClass: string | string[];
                viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                minSize: number;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
            onScroll?: ((args_0: {
                scrollTop: number;
                scrollLeft: number;
            }) => any) | undefined;
            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
        }>, {
            wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            update: () => void;
            scrollTo: {
                (xCord: number, yCord?: number): void;
                (options: ScrollToOptions): void;
            };
            setScrollTop: (value: number) => void;
            setScrollLeft: (value: number) => void;
            handleScroll: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            scroll: (args_0: {
                scrollTop: number;
                scrollLeft: number;
            }) => void;
            "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
        }, string, {
            tag: keyof HTMLElementTagNameMap | (string & {});
            tabindex: number | string;
            height: number | string;
            maxHeight: number | string;
            distance: number;
            wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            wrapClass: string | string[];
            viewClass: string | string[];
            viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            minSize: number;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            };
        })>;
        ElTooltip: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").UseTooltipProps> & Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
                onHide?: ((...args: any[]) => any) | undefined;
                onShow?: ((...args: any[]) => any) | undefined;
                onOpen?: ((...args: any[]) => any) | undefined;
                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                "onBefore-show"?: ((...args: any[]) => any) | undefined;
                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
            }>, {
                popperRef: import("vue").Ref<import("element-plus").PopperInstance | undefined, import("element-plus").PopperInstance | undefined>;
                contentRef: import("vue").Ref<import("element-plus").TooltipContentInstance | undefined, import("element-plus").TooltipContentInstance | undefined>;
                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                updatePopper: () => void;
                onOpen: (event?: Event, delay?: number) => void;
                onClose: (event?: Event, delay?: number) => void;
                hide: (event?: Event) => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                close: (...args: any[]) => void;
                hide: (...args: any[]) => void;
                show: (...args: any[]) => void;
                open: (...args: any[]) => void;
                "update:visible": (...args: any[]) => void;
                "before-show": (...args: any[]) => void;
                "before-hide": (...args: any[]) => void;
            }, import("vue").PublicProps, {
                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                role: "group" | "dialog" | "menu" | "tooltip" | "tree" | "listbox" | "grid" | "navigation";
                visible: boolean | null;
                content: string;
                teleported: boolean;
                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                effect: import("element-plus").PopperEffect;
                enterable: boolean;
                pure: boolean;
                focusOnShow: boolean;
                trapping: boolean;
                stopPopperMouseEvent: boolean;
                virtualTriggering: boolean;
                loop: boolean;
                boundariesPadding: number;
                gpuAcceleration: boolean;
                offset: number;
                placement: import("element-plus").Placement;
                popperOptions: Partial<import("element-plus").Options>;
                strategy: "absolute" | "fixed";
                arrowOffset: number;
                showArrow: boolean;
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                trigger: import("element-plus/es/utils/typescript.mjs").Arrayable<import("element-plus").TooltipTriggerType>;
                triggerKeys: string[];
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").UseTooltipProps> & Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
                onHide?: ((...args: any[]) => any) | undefined;
                onShow?: ((...args: any[]) => any) | undefined;
                onOpen?: ((...args: any[]) => any) | undefined;
                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                "onBefore-show"?: ((...args: any[]) => any) | undefined;
                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
            }>, {
                popperRef: import("vue").Ref<import("element-plus").PopperInstance | undefined, import("element-plus").PopperInstance | undefined>;
                contentRef: import("vue").Ref<import("element-plus").TooltipContentInstance | undefined, import("element-plus").TooltipContentInstance | undefined>;
                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                updatePopper: () => void;
                onOpen: (event?: Event, delay?: number) => void;
                onClose: (event?: Event, delay?: number) => void;
                hide: (event?: Event) => void;
            }, {}, {}, {}, {
                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                role: "group" | "dialog" | "menu" | "tooltip" | "tree" | "listbox" | "grid" | "navigation";
                visible: boolean | null;
                content: string;
                teleported: boolean;
                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
                effect: import("element-plus").PopperEffect;
                enterable: boolean;
                pure: boolean;
                focusOnShow: boolean;
                trapping: boolean;
                stopPopperMouseEvent: boolean;
                virtualTriggering: boolean;
                loop: boolean;
                boundariesPadding: number;
                gpuAcceleration: boolean;
                offset: number;
                placement: import("element-plus").Placement;
                popperOptions: Partial<import("element-plus").Options>;
                strategy: "absolute" | "fixed";
                arrowOffset: number;
                showArrow: boolean;
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                trigger: import("element-plus/es/utils/typescript.mjs").Arrayable<import("element-plus").TooltipTriggerType>;
                triggerKeys: string[];
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").UseTooltipProps> & Readonly<{
            onClose?: ((...args: any[]) => any) | undefined;
            onHide?: ((...args: any[]) => any) | undefined;
            onShow?: ((...args: any[]) => any) | undefined;
            onOpen?: ((...args: any[]) => any) | undefined;
            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
            "onBefore-show"?: ((...args: any[]) => any) | undefined;
            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
        }>, {
            popperRef: import("vue").Ref<import("element-plus").PopperInstance | undefined, import("element-plus").PopperInstance | undefined>;
            contentRef: import("vue").Ref<import("element-plus").TooltipContentInstance | undefined, import("element-plus").TooltipContentInstance | undefined>;
            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
            updatePopper: () => void;
            onOpen: (event?: Event, delay?: number) => void;
            onClose: (event?: Event, delay?: number) => void;
            hide: (event?: Event) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            close: (...args: any[]) => void;
            hide: (...args: any[]) => void;
            show: (...args: any[]) => void;
            open: (...args: any[]) => void;
            "update:visible": (...args: any[]) => void;
            "before-show": (...args: any[]) => void;
            "before-hide": (...args: any[]) => void;
        }, string, {
            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            role: "group" | "dialog" | "menu" | "tooltip" | "tree" | "listbox" | "grid" | "navigation";
            visible: boolean | null;
            content: string;
            teleported: boolean;
            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
            effect: import("element-plus").PopperEffect;
            enterable: boolean;
            pure: boolean;
            focusOnShow: boolean;
            trapping: boolean;
            stopPopperMouseEvent: boolean;
            virtualTriggering: boolean;
            loop: boolean;
            boundariesPadding: number;
            gpuAcceleration: boolean;
            offset: number;
            placement: import("element-plus").Placement;
            popperOptions: Partial<import("element-plus").Options>;
            strategy: "absolute" | "fixed";
            arrowOffset: number;
            showArrow: boolean;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            trigger: import("element-plus/es/utils/typescript.mjs").Arrayable<import("element-plus").TooltipTriggerType>;
            triggerKeys: string[];
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            } & {
                content?: (props: {}) => any;
            };
        })>;
        ElIcon: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            };
        })>;
    } & import("vue").GlobalComponents, {
        ClickOutside: import("vue").ObjectDirective<HTMLElement, any, string, any>;
    } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        ariaLabel: StringConstructor;
        emptyValues: ArrayConstructor;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
        name: StringConstructor;
        id: StringConstructor;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown, undefined, boolean>;
        autocomplete: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        automaticDropdown: BooleanConstructor;
        size: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        effect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown, string, boolean>;
        disabled: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
        clearable: BooleanConstructor;
        filterable: BooleanConstructor;
        allowCreate: BooleanConstructor;
        loading: BooleanConstructor;
        popperClass: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        popperStyle: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties) | (((new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        popperOptions: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => Partial<import("element-plus").Options>, boolean>;
        remote: BooleanConstructor;
        debounce: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        loadingText: StringConstructor;
        noMatchText: StringConstructor;
        noDataText: StringConstructor;
        remoteMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        filterMethod: {
            readonly type: import("vue").PropType<(query: string) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        multiple: BooleanConstructor;
        multipleLimit: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placeholder: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        defaultFirstOption: BooleanConstructor;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        valueKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        collapseTags: BooleanConstructor;
        collapseTagsTooltip: BooleanConstructor;
        tagTooltip: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps) | (((new (...args: any[]) => import("element-plus").TagTooltipProps) | (() => import("element-plus").TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
        maxCollapseTags: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        fitInputWidth: BooleanConstructor;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
        tagType: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        tagEffect: {
            default: string;
            type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
            required: false;
            validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        remoteShowSuffix: BooleanConstructor;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        offset: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        placement: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, string, boolean>;
        fallbackPlacements: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, string[], boolean>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
        appendTo: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        options: {
            readonly type: import("vue").PropType<Record<string, any>[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (((new (...args: any[]) => import("element-plus/es/components/select-v2/src/useProps.mjs").Props) | (() => import("element-plus/es/components/select-v2/src/useProps.mjs").Props)) | null)[], unknown, unknown, () => Required<import("element-plus/es/components/select-v2/src/useProps.mjs").Props>, boolean>;
    }>> & Readonly<{
        onClear?: (() => any) | undefined;
        "onUpdate:modelValue"?: ((val: any) => any) | undefined;
        onChange?: ((val: any) => any) | undefined;
        onBlur?: ((evt: FocusEvent) => any) | undefined;
        onFocus?: ((evt: FocusEvent) => any) | undefined;
        "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
        "onVisible-change"?: ((visible: boolean) => any) | undefined;
        "onRemove-tag"?: ((val: unknown) => any) | undefined;
        "onPopup-scroll"?: ((args_0: {
            scrollTop: number;
            scrollLeft: number;
        }) => any) | undefined;
    }>, {
        modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
        selectedLabel: import("vue").ComputedRef<string | string[]>;
        calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        inputStyle: import("vue").ComputedRef<{
            minWidth: string;
        }>;
        getLabel: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getValue: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptions: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getDisabled: (option: import("element-plus/es/components/select-v2/src/select.types.mjs").Option) => any;
        getOptionProps: (option: Record<string, any>) => {
            label: any;
            value: any;
            disabled: any;
        };
        inputId: import("vue").Ref<string | undefined, string | undefined>;
        contentId: import("vue").Ref<string, 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<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            cachedOptions: Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy> & Omit<Map<import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("element-plus").SelectOptionProxy>, keyof Map<any, any>>;
            optionValues: import("element-plus/es/components/select/src/type.mjs").OptionValue[];
            selected: {
                index: number;
                value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
                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, boolean>;
        expanded: import("vue").Ref<boolean, boolean>;
        optionsArray: import("vue").ComputedRef<import("element-plus").SelectOptionProxy[]>;
        hoverOption: import("vue").Ref<any, any>;
        selectSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
        filteredOptionsCount: import("vue").ComputedRef<number>;
        updateTooltip: () => void;
        updateTagTooltip: () => void;
        debouncedOnInputChange: import("@vueuse/core").UseDebounceFnReturn<() => void>;
        onInput: (event: Event) => void;
        deletePrevTag: (e: KeyboardEvent) => void;
        deleteTag: (event: MouseEvent, tag: 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/es/components/select/src/type.mjs").SelectStates["selected"]) => void;
        hasModelValue: import("vue").ComputedRef<boolean>;
        shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
        currentPlaceholder: import("vue").ComputedRef<string>;
        mouseEnterEventName: string | null;
        needStatusIcon: import("vue").ComputedRef<boolean>;
        showClearBtn: import("vue").ComputedRef<boolean>;
        iconComponent: import("vue").ComputedRef<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
        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;
        handleKeydown: (e: KeyboardEvent) => void;
        onOptionCreate: (vm: import("element-plus").SelectOptionProxy) => void;
        onOptionDestroy: (key: import("element-plus/es/components/select/src/type.mjs").OptionValue, vm: import("element-plus").SelectOptionProxy) => void;
        handleMenuEnter: () => void;
        focus: () => void;
        blur: () => void;
        handleClearClick: (event: Event) => void;
        handleClickOutside: (event: Event) => void;
        handleEsc: () => void;
        toggleMenu: (event?: Event) => void;
        selectOption: () => void;
        getValueKey: (item: import("element-plus").SelectOptionProxy | import("element-plus/es/components/select/src/type.mjs").SelectStates["selected"][0]) => any;
        navigateOptions: (direction: "prev" | "next") => void;
        dropdownMenuVisible: import("vue").WritableComputedRef<boolean, boolean>;
        showTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        collapseTagList: import("vue").ComputedRef<{
            index: number;
            value: import("element-plus/es/components/select/src/type.mjs").OptionValue;
            currentLabel: import("element-plus").SelectOptionProxy["currentLabel"];
            isDisabled?: import("element-plus").SelectOptionProxy["isDisabled"] | undefined;
        }[]>;
        popupScroll: (data: {
            scrollTop: number;
            scrollLeft: number;
        }) => void;
        getOption: (value: import("element-plus/es/components/select/src/type.mjs").OptionValue) => {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: any;
        } | {
            index: number;
            value: import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
            currentLabel: string | number | boolean;
            readonly isDisabled: boolean;
        };
        endReached: (direction: import("element-plus").ScrollbarDirection) => 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, HTMLInputElement | undefined>;
        tooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        tagTooltipRef: import("vue").Ref<import("element-plus").TooltipInstance | undefined, import("element-plus").TooltipInstance | undefined>;
        prefixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        suffixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        selectRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        wrapperRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
        selectionRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        scrollbarRef: import("vue").Ref<import("element-plus").ScrollbarInstance | undefined, import("element-plus").ScrollbarInstance | undefined>;
        menuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        tagMenuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
        collapseItemRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
    }, {}, {}, {}, {
        props: import("element-plus/es/components/select-v2/src/useProps.mjs").Props;
        modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("element-plus/es/utils/index.mjs").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown>;
        loading: boolean;
        disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tabindex: import("element-plus/es/utils/index.mjs").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>;
        validateEvent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        multiple: boolean;
        valueOnClear: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
        teleported: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        persistent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        popperClass: string;
        effect: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | (((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect)) | null)[], unknown, unknown>;
        fallbackPlacements: import("element-plus").Placement[];
        offset: number;
        placement: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
        popperOptions: Partial<import("element-plus").Options>;
        showArrow: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        autocomplete: string;
        clearable: boolean;
        clearIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        suffixIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
        valueKey: string;
        debounce: number;
        fitInputWidth: boolean;
        filterable: boolean;
        collapseTags: boolean;
        maxCollapseTags: number;
        collapseTagsTooltip: boolean;
        tagType: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "info" | "warning" | "danger", unknown>;
        tagEffect: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>;
        automaticDropdown: boolean;
        allowCreate: boolean;
        remote: boolean;
        multipleLimit: number;
        defaultFirstOption: boolean;
        reserveKeyword: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        tagTooltip: import("element-plus").TagTooltipProps;
        remoteShowSuffix: boolean;
    }> | undefined>;
    elTreeCtx: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        readonly data: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData) | (((new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
        readonly emptyText: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly nodeKey: StringConstructor;
        readonly checkStrictly: BooleanConstructor;
        readonly defaultExpandAll: BooleanConstructor;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkOnClickNode: BooleanConstructor;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkDescendants: BooleanConstructor;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly defaultCheckedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly defaultExpandedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly currentNodeKey: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderContent: {
            readonly type: import("vue").PropType<import("element-plus").RenderContentFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly showCheckbox: BooleanConstructor;
        readonly draggable: BooleanConstructor;
        readonly allowDrag: {
            readonly type: import("vue").PropType<import("element-plus").AllowDragFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly allowDrop: {
            readonly type: import("vue").PropType<import("element-plus").AllowDropFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps) | (((new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps)) | null)[], unknown, unknown, () => {
            children: string;
            label: string;
            disabled: string;
        }, boolean>;
        readonly lazy: BooleanConstructor;
        readonly highlightCurrent: BooleanConstructor;
        readonly load: {
            readonly type: import("vue").PropType<import("element-plus").LoadFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly filterNodeMethod: {
            readonly type: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly accordion: BooleanConstructor;
        readonly indent: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
        readonly icon: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>> & Readonly<{
        "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
        "onNode-expand"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
        "onNode-click"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null, evt: MouseEvent) => any) | undefined;
        "onNode-contextmenu"?: ((evt: Event, data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onNode-collapse"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        onCheck?: ((data: any, checkedInfo: import("element-plus").CheckedInfo) => any) | undefined;
        "onNode-drag-start"?: ((node: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-end"?: ((draggingNode: Node, dropNode: Node | null, dropType: import("element-plus").NodeDropType, evt: DragEvent) => any) | undefined;
        "onNode-drop"?: ((draggingNode: Node, dropNode: Node, dropType: "after" | "before" | "inner", evt: DragEvent) => any) | undefined;
        "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
    }>, {
        ns: {
            namespace: import("vue").ComputedRef<string>;
            b: (blockSuffix?: string) => string;
            e: (element?: string) => string;
            m: (modifier?: string) => string;
            be: (blockSuffix?: string, element?: string) => string;
            em: (element?: string, modifier?: string) => string;
            bm: (blockSuffix?: string, modifier?: string) => string;
            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
            is: {
                (name: string, state: boolean | undefined): string;
                (name: string): string;
            };
            cssVar: (object: Record<string, string>) => Record<string, string>;
            cssVarName: (name: string) => string;
            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
            cssVarBlockName: (name: string) => string;
        };
        store: import("vue").Ref<{
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }, import("element-plus/es/components/tree/src/model/tree-store.mjs").default | {
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }>;
        root: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }>;
        currentNode: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null>;
        dragState: import("vue").Ref<{
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }, {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
            showDropIndicator: boolean;
            dropNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
        } | {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }>;
        el$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        dropIndicator$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        isEmpty: import("vue").ComputedRef<boolean>;
        filter: (value: import("element-plus").FilterValue) => void;
        getNodeKey: (node: Node) => any;
        getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
        getCurrentNode: () => TreeNodeData | null;
        getCurrentKey: () => TreeKey | null;
        setCheckedNodes: (nodes: Node[], leafOnly?: boolean) => void;
        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep?: boolean) => void;
        getHalfCheckedNodes: () => TreeNodeData[];
        getHalfCheckedKeys: () => TreeKey[];
        setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
        setCurrentKey: (key?: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        t: import("element-plus").Translator;
        getNode: (data: TreeKey | TreeNodeData) => Node;
        remove: (data: TreeNodeData | Node) => void;
        append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void;
        insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: import("vue").ComponentInternalInstance) => void;
        updateKeyChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
        'current-change': (data: any | null, node: Node | null) => boolean;
        'node-click': (data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null, evt: MouseEvent) => any;
        'node-contextmenu': (evt: Event, data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any;
        'node-collapse': (data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any;
        'node-expand': (data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any;
        check: (data: any, checkedInfo: import("element-plus").CheckedInfo) => any;
        'node-drag-start': (node: Node, evt: DragEvent) => DragEvent;
        'node-drag-end': (draggingNode: Node, dropNode: Node | null, dropType: import("element-plus").NodeDropType, evt: DragEvent) => DragEvent;
        'node-drop': (draggingNode: Node, dropNode: Node, dropType: Exclude<import("element-plus").NodeDropType, "none">, evt: DragEvent) => DragEvent;
        'node-drag-leave': (draggingNode: Node, oldDropNode: Node, evt: DragEvent) => DragEvent;
        'node-drag-enter': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
        'node-drag-over': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
    }, import("vue").PublicProps, {
        readonly props: import("element-plus").TreeOptionProps;
        readonly data: import("element-plus").TreeData;
        readonly checkStrictly: boolean;
        readonly lazy: boolean;
        readonly checkOnClickNode: boolean;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly accordion: boolean;
        readonly draggable: boolean;
        readonly defaultExpandAll: boolean;
        readonly indent: number;
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly showCheckbox: boolean;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly checkDescendants: boolean;
        readonly highlightCurrent: boolean;
    }, true, {}, {}, {
        ElTreeNode: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            node: {
                type: typeof Node;
                default: () => {};
            };
            props: {
                type: import("vue").PropType<import("element-plus").TreeOptionProps>;
                default: () => {};
            };
            accordion: BooleanConstructor;
            renderContent: FunctionConstructor;
            renderAfterExpand: BooleanConstructor;
            showCheckbox: BooleanConstructor;
        }>, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            node$: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            tree: import("element-plus").RootTreeType;
            expanded: import("vue").Ref<boolean, boolean>;
            childNodeRendered: import("vue").Ref<boolean, boolean>;
            oldChecked: import("vue").Ref<boolean | undefined, boolean | undefined>;
            oldIndeterminate: import("vue").Ref<boolean | undefined, boolean | undefined>;
            getNodeKey: (node: Node) => any;
            getNodeClass: (node: Node) => {
                [key: string]: boolean;
            };
            handleSelectChange: (checked: boolean, indeterminate: boolean) => void;
            handleClick: (e: MouseEvent) => void;
            handleContextMenu: (event: Event) => void;
            handleExpandIconClick: () => void;
            handleCheckChange: (value: import("element-plus").CheckboxValueType) => void;
            handleChildNodeExpand: (nodeData: TreeNodeData, node: Node, instance: import("vue").ComponentInternalInstance) => void;
            handleDragStart: (event: DragEvent) => void;
            handleDragOver: (event: DragEvent) => void;
            handleDrop: (event: DragEvent) => void;
            handleDragEnd: (event: DragEvent) => void;
            CaretRight: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "node-expand"[], "node-expand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            node: {
                type: typeof Node;
                default: () => {};
            };
            props: {
                type: import("vue").PropType<import("element-plus").TreeOptionProps>;
                default: () => {};
            };
            accordion: BooleanConstructor;
            renderContent: FunctionConstructor;
            renderAfterExpand: BooleanConstructor;
            showCheckbox: BooleanConstructor;
        }>> & Readonly<{
            "onNode-expand"?: ((...args: any[]) => any) | undefined;
        }>, {
            props: import("element-plus").TreeOptionProps;
            accordion: boolean;
            node: Node;
            renderAfterExpand: boolean;
            showCheckbox: boolean;
        }, {}, {
            ElCollapseTransition: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                $slots: {
                    default?: (props: {}) => any;
                };
            })>;
            ElCheckbox: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                    change: (val: import("element-plus").CheckboxValueType) => void;
                }, import("vue").PublicProps, {
                    modelValue: number | string | boolean;
                    label: string | boolean | number | object;
                    disabled: boolean;
                    value: string | boolean | number | object;
                    name: string;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                    id: string;
                    validateEvent: boolean;
                }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("element-plus").CheckboxProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                }>, {}, {}, {}, {}, {
                    modelValue: number | string | boolean;
                    label: string | boolean | number | object;
                    disabled: boolean;
                    value: string | boolean | number | object;
                    name: string;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                    id: string;
                    validateEvent: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                change: (val: import("element-plus").CheckboxValueType) => void;
            }, string, {
                modelValue: number | string | boolean;
                label: string | boolean | number | object;
                disabled: boolean;
                value: string | boolean | number | object;
                name: string;
                trueValue: string | number;
                falseValue: string | number;
                trueLabel: string | number;
                falseLabel: string | number;
                id: string;
                validateEvent: boolean;
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                $slots: {
                    default?: (props: {}) => any;
                };
            }) & import("vue").ObjectPlugin & {
                setPropsDefaults: (defaults: {
                    readonly modelValue?: string | number | boolean | (() => string | number | boolean) | undefined;
                    readonly label?: string | number | boolean | (() => string | number | boolean | object) | undefined;
                    readonly value?: string | number | boolean | (() => string | number | boolean | object) | undefined;
                    readonly indeterminate?: boolean | (() => boolean) | undefined;
                    readonly disabled?: boolean | (() => boolean) | undefined;
                    readonly checked?: boolean | (() => boolean) | undefined;
                    readonly name?: string | (() => string) | undefined;
                    readonly trueValue?: string | number | (() => string | number) | undefined;
                    readonly falseValue?: string | number | (() => string | number) | undefined;
                    readonly trueLabel?: string | number | (() => string | number) | undefined;
                    readonly falseLabel?: string | number | (() => string | number) | undefined;
                    readonly id?: string | (() => string) | undefined;
                    readonly border?: boolean | (() => boolean) | undefined;
                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
                    readonly tabindex?: string | number | (() => string | number) | undefined;
                    readonly validateEvent?: boolean | (() => boolean) | undefined;
                    readonly ariaLabel?: string | (() => string) | undefined;
                    readonly ariaControls?: string | (() => string) | undefined;
                }) => void;
            } & {
                CheckboxButton: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                        "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                        change: (val: import("element-plus").CheckboxValueType) => void;
                    }, import("vue").PublicProps, {
                        modelValue: number | string | boolean;
                        label: string | boolean | number | object;
                        disabled: boolean;
                        value: string | boolean | number | object;
                        name: string;
                        trueValue: string | number;
                        falseValue: string | number;
                        trueLabel: string | number;
                        falseLabel: string | number;
                        id: string;
                        validateEvent: boolean;
                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("element-plus").CheckboxProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    }>, {}, {}, {}, {}, {
                        modelValue: number | string | boolean;
                        label: string | boolean | number | object;
                        disabled: boolean;
                        value: string | boolean | number | object;
                        name: string;
                        trueValue: string | number;
                        falseValue: string | number;
                        trueLabel: string | number;
                        falseLabel: string | number;
                        id: string;
                        validateEvent: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                    change: (val: import("element-plus").CheckboxValueType) => void;
                }, string, {
                    modelValue: number | string | boolean;
                    label: string | boolean | number | object;
                    disabled: boolean;
                    value: string | boolean | number | object;
                    name: string;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                    id: string;
                    validateEvent: boolean;
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                    $slots: {
                        default?: (props: {}) => any;
                    };
                });
                CheckboxGroup: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").CheckboxGroupProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                        "update:modelValue": (val: import("element-plus").CheckboxGroupValueType) => void;
                        change: (val: import("element-plus").CheckboxValueType[]) => void;
                    }, import("vue").PublicProps, {
                        props: {
                            value?: string;
                            label?: string;
                            disabled?: string;
                        };
                        type: "checkbox" | "button";
                        modelValue: import("element-plus").CheckboxGroupValueType;
                        tag: string;
                        disabled: boolean;
                        validateEvent: boolean;
                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("element-plus").CheckboxGroupProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
                    }>, {}, {}, {}, {}, {
                        props: {
                            value?: string;
                            label?: string;
                            disabled?: string;
                        };
                        type: "checkbox" | "button";
                        modelValue: import("element-plus").CheckboxGroupValueType;
                        tag: string;
                        disabled: boolean;
                        validateEvent: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").CheckboxGroupProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    "update:modelValue": (val: import("element-plus").CheckboxGroupValueType) => void;
                    change: (val: import("element-plus").CheckboxValueType[]) => void;
                }, string, {
                    props: {
                        value?: string;
                        label?: string;
                        disabled?: string;
                    };
                    type: "checkbox" | "button";
                    modelValue: import("element-plus").CheckboxGroupValueType;
                    tag: string;
                    disabled: boolean;
                    validateEvent: boolean;
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                    $slots: {
                        default?: (props: {}) => any;
                    };
                });
            };
            NodeContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                node: {
                    type: ObjectConstructor;
                    required: true;
                };
                renderContent: FunctionConstructor;
            }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                node: {
                    type: ObjectConstructor;
                    required: true;
                };
                renderContent: FunctionConstructor;
            }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            ElIcon: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                $slots: {
                    default?: (props: {}) => any;
                };
            })>;
            Loading: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        readonly data: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData) | (((new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
        readonly emptyText: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly nodeKey: StringConstructor;
        readonly checkStrictly: BooleanConstructor;
        readonly defaultExpandAll: BooleanConstructor;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkOnClickNode: BooleanConstructor;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkDescendants: BooleanConstructor;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly defaultCheckedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly defaultExpandedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly currentNodeKey: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderContent: {
            readonly type: import("vue").PropType<import("element-plus").RenderContentFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly showCheckbox: BooleanConstructor;
        readonly draggable: BooleanConstructor;
        readonly allowDrag: {
            readonly type: import("vue").PropType<import("element-plus").AllowDragFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly allowDrop: {
            readonly type: import("vue").PropType<import("element-plus").AllowDropFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps) | (((new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps)) | null)[], unknown, unknown, () => {
            children: string;
            label: string;
            disabled: string;
        }, boolean>;
        readonly lazy: BooleanConstructor;
        readonly highlightCurrent: BooleanConstructor;
        readonly load: {
            readonly type: import("vue").PropType<import("element-plus").LoadFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly filterNodeMethod: {
            readonly type: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly accordion: BooleanConstructor;
        readonly indent: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
        readonly icon: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>> & Readonly<{
        "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
        "onNode-expand"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
        "onNode-click"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null, evt: MouseEvent) => any) | undefined;
        "onNode-contextmenu"?: ((evt: Event, data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onNode-collapse"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        onCheck?: ((data: any, checkedInfo: import("element-plus").CheckedInfo) => any) | undefined;
        "onNode-drag-start"?: ((node: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-end"?: ((draggingNode: Node, dropNode: Node | null, dropType: import("element-plus").NodeDropType, evt: DragEvent) => any) | undefined;
        "onNode-drop"?: ((draggingNode: Node, dropNode: Node, dropType: "after" | "before" | "inner", evt: DragEvent) => any) | undefined;
        "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
    }>, {
        ns: {
            namespace: import("vue").ComputedRef<string>;
            b: (blockSuffix?: string) => string;
            e: (element?: string) => string;
            m: (modifier?: string) => string;
            be: (blockSuffix?: string, element?: string) => string;
            em: (element?: string, modifier?: string) => string;
            bm: (blockSuffix?: string, modifier?: string) => string;
            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
            is: {
                (name: string, state: boolean | undefined): string;
                (name: string): string;
            };
            cssVar: (object: Record<string, string>) => Record<string, string>;
            cssVarName: (name: string) => string;
            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
            cssVarBlockName: (name: string) => string;
        };
        store: import("vue").Ref<{
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }, import("element-plus/es/components/tree/src/model/tree-store.mjs").default | {
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }>;
        root: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }>;
        currentNode: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null>;
        dragState: import("vue").Ref<{
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }, {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
            showDropIndicator: boolean;
            dropNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
        } | {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }>;
        el$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        dropIndicator$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        isEmpty: import("vue").ComputedRef<boolean>;
        filter: (value: import("element-plus").FilterValue) => void;
        getNodeKey: (node: Node) => any;
        getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
        getCurrentNode: () => TreeNodeData | null;
        getCurrentKey: () => TreeKey | null;
        setCheckedNodes: (nodes: Node[], leafOnly?: boolean) => void;
        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep?: boolean) => void;
        getHalfCheckedNodes: () => TreeNodeData[];
        getHalfCheckedKeys: () => TreeKey[];
        setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
        setCurrentKey: (key?: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        t: import("element-plus").Translator;
        getNode: (data: TreeKey | TreeNodeData) => Node;
        remove: (data: TreeNodeData | Node) => void;
        append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void;
        insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: import("vue").ComponentInternalInstance) => void;
        updateKeyChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
    }, {}, {}, {}, {
        readonly props: import("element-plus").TreeOptionProps;
        readonly data: import("element-plus").TreeData;
        readonly checkStrictly: boolean;
        readonly lazy: boolean;
        readonly checkOnClickNode: boolean;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly accordion: boolean;
        readonly draggable: boolean;
        readonly defaultExpandAll: boolean;
        readonly indent: number;
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly showCheckbox: boolean;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly checkDescendants: boolean;
        readonly highlightCurrent: boolean;
    }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        readonly data: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData) | (((new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
        readonly emptyText: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly nodeKey: StringConstructor;
        readonly checkStrictly: BooleanConstructor;
        readonly defaultExpandAll: BooleanConstructor;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkOnClickNode: BooleanConstructor;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkDescendants: BooleanConstructor;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly defaultCheckedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly defaultExpandedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly currentNodeKey: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderContent: {
            readonly type: import("vue").PropType<import("element-plus").RenderContentFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly showCheckbox: BooleanConstructor;
        readonly draggable: BooleanConstructor;
        readonly allowDrag: {
            readonly type: import("vue").PropType<import("element-plus").AllowDragFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly allowDrop: {
            readonly type: import("vue").PropType<import("element-plus").AllowDropFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps) | (((new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps)) | null)[], unknown, unknown, () => {
            children: string;
            label: string;
            disabled: string;
        }, boolean>;
        readonly lazy: BooleanConstructor;
        readonly highlightCurrent: BooleanConstructor;
        readonly load: {
            readonly type: import("vue").PropType<import("element-plus").LoadFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly filterNodeMethod: {
            readonly type: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly accordion: BooleanConstructor;
        readonly indent: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
        readonly icon: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>> & Readonly<{
        "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
        "onNode-expand"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
        "onNode-click"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null, evt: MouseEvent) => any) | undefined;
        "onNode-contextmenu"?: ((evt: Event, data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onNode-collapse"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        onCheck?: ((data: any, checkedInfo: import("element-plus").CheckedInfo) => any) | undefined;
        "onNode-drag-start"?: ((node: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-end"?: ((draggingNode: Node, dropNode: Node | null, dropType: import("element-plus").NodeDropType, evt: DragEvent) => any) | undefined;
        "onNode-drop"?: ((draggingNode: Node, dropNode: Node, dropType: "after" | "before" | "inner", evt: DragEvent) => any) | undefined;
        "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
    }>, {
        ns: {
            namespace: import("vue").ComputedRef<string>;
            b: (blockSuffix?: string) => string;
            e: (element?: string) => string;
            m: (modifier?: string) => string;
            be: (blockSuffix?: string, element?: string) => string;
            em: (element?: string, modifier?: string) => string;
            bm: (blockSuffix?: string, modifier?: string) => string;
            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
            is: {
                (name: string, state: boolean | undefined): string;
                (name: string): string;
            };
            cssVar: (object: Record<string, string>) => Record<string, string>;
            cssVarName: (name: string) => string;
            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
            cssVarBlockName: (name: string) => string;
        };
        store: import("vue").Ref<{
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }, import("element-plus/es/components/tree/src/model/tree-store.mjs").default | {
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }>;
        root: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }>;
        currentNode: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null>;
        dragState: import("vue").Ref<{
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }, {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
            showDropIndicator: boolean;
            dropNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
        } | {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }>;
        el$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        dropIndicator$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        isEmpty: import("vue").ComputedRef<boolean>;
        filter: (value: import("element-plus").FilterValue) => void;
        getNodeKey: (node: Node) => any;
        getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
        getCurrentNode: () => TreeNodeData | null;
        getCurrentKey: () => TreeKey | null;
        setCheckedNodes: (nodes: Node[], leafOnly?: boolean) => void;
        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep?: boolean) => void;
        getHalfCheckedNodes: () => TreeNodeData[];
        getHalfCheckedKeys: () => TreeKey[];
        setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
        setCurrentKey: (key?: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        t: import("element-plus").Translator;
        getNode: (data: TreeKey | TreeNodeData) => Node;
        remove: (data: TreeNodeData | Node) => void;
        append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void;
        insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: import("vue").ComponentInternalInstance) => void;
        updateKeyChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
        'current-change': (data: any | null, node: Node | null) => boolean;
        'node-click': (data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null, evt: MouseEvent) => any;
        'node-contextmenu': (evt: Event, data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any;
        'node-collapse': (data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any;
        'node-expand': (data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any;
        check: (data: any, checkedInfo: import("element-plus").CheckedInfo) => any;
        'node-drag-start': (node: Node, evt: DragEvent) => DragEvent;
        'node-drag-end': (draggingNode: Node, dropNode: Node | null, dropType: import("element-plus").NodeDropType, evt: DragEvent) => DragEvent;
        'node-drop': (draggingNode: Node, dropNode: Node, dropType: Exclude<import("element-plus").NodeDropType, "none">, evt: DragEvent) => DragEvent;
        'node-drag-leave': (draggingNode: Node, oldDropNode: Node, evt: DragEvent) => DragEvent;
        'node-drag-enter': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
        'node-drag-over': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
    }, import("vue").PublicProps, {
        readonly props: import("element-plus").TreeOptionProps;
        readonly data: import("element-plus").TreeData;
        readonly checkStrictly: boolean;
        readonly lazy: boolean;
        readonly checkOnClickNode: boolean;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly accordion: boolean;
        readonly draggable: boolean;
        readonly defaultExpandAll: boolean;
        readonly indent: number;
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly showCheckbox: boolean;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly checkDescendants: boolean;
        readonly highlightCurrent: boolean;
    }, true, {}, {}, {
        ElTreeNode: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            node: {
                type: typeof Node;
                default: () => {};
            };
            props: {
                type: import("vue").PropType<import("element-plus").TreeOptionProps>;
                default: () => {};
            };
            accordion: BooleanConstructor;
            renderContent: FunctionConstructor;
            renderAfterExpand: BooleanConstructor;
            showCheckbox: BooleanConstructor;
        }>, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            node$: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            tree: import("element-plus").RootTreeType;
            expanded: import("vue").Ref<boolean, boolean>;
            childNodeRendered: import("vue").Ref<boolean, boolean>;
            oldChecked: import("vue").Ref<boolean | undefined, boolean | undefined>;
            oldIndeterminate: import("vue").Ref<boolean | undefined, boolean | undefined>;
            getNodeKey: (node: Node) => any;
            getNodeClass: (node: Node) => {
                [key: string]: boolean;
            };
            handleSelectChange: (checked: boolean, indeterminate: boolean) => void;
            handleClick: (e: MouseEvent) => void;
            handleContextMenu: (event: Event) => void;
            handleExpandIconClick: () => void;
            handleCheckChange: (value: import("element-plus").CheckboxValueType) => void;
            handleChildNodeExpand: (nodeData: TreeNodeData, node: Node, instance: import("vue").ComponentInternalInstance) => void;
            handleDragStart: (event: DragEvent) => void;
            handleDragOver: (event: DragEvent) => void;
            handleDrop: (event: DragEvent) => void;
            handleDragEnd: (event: DragEvent) => void;
            CaretRight: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "node-expand"[], "node-expand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            node: {
                type: typeof Node;
                default: () => {};
            };
            props: {
                type: import("vue").PropType<import("element-plus").TreeOptionProps>;
                default: () => {};
            };
            accordion: BooleanConstructor;
            renderContent: FunctionConstructor;
            renderAfterExpand: BooleanConstructor;
            showCheckbox: BooleanConstructor;
        }>> & Readonly<{
            "onNode-expand"?: ((...args: any[]) => any) | undefined;
        }>, {
            props: import("element-plus").TreeOptionProps;
            accordion: boolean;
            node: Node;
            renderAfterExpand: boolean;
            showCheckbox: boolean;
        }, {}, {
            ElCollapseTransition: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                $slots: {
                    default?: (props: {}) => any;
                };
            })>;
            ElCheckbox: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                    change: (val: import("element-plus").CheckboxValueType) => void;
                }, import("vue").PublicProps, {
                    modelValue: number | string | boolean;
                    label: string | boolean | number | object;
                    disabled: boolean;
                    value: string | boolean | number | object;
                    name: string;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                    id: string;
                    validateEvent: boolean;
                }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("element-plus").CheckboxProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                }>, {}, {}, {}, {}, {
                    modelValue: number | string | boolean;
                    label: string | boolean | number | object;
                    disabled: boolean;
                    value: string | boolean | number | object;
                    name: string;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                    id: string;
                    validateEvent: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                change: (val: import("element-plus").CheckboxValueType) => void;
            }, string, {
                modelValue: number | string | boolean;
                label: string | boolean | number | object;
                disabled: boolean;
                value: string | boolean | number | object;
                name: string;
                trueValue: string | number;
                falseValue: string | number;
                trueLabel: string | number;
                falseLabel: string | number;
                id: string;
                validateEvent: boolean;
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                $slots: {
                    default?: (props: {}) => any;
                };
            }) & import("vue").ObjectPlugin & {
                setPropsDefaults: (defaults: {
                    readonly modelValue?: string | number | boolean | (() => string | number | boolean) | undefined;
                    readonly label?: string | number | boolean | (() => string | number | boolean | object) | undefined;
                    readonly value?: string | number | boolean | (() => string | number | boolean | object) | undefined;
                    readonly indeterminate?: boolean | (() => boolean) | undefined;
                    readonly disabled?: boolean | (() => boolean) | undefined;
                    readonly checked?: boolean | (() => boolean) | undefined;
                    readonly name?: string | (() => string) | undefined;
                    readonly trueValue?: string | number | (() => string | number) | undefined;
                    readonly falseValue?: string | number | (() => string | number) | undefined;
                    readonly trueLabel?: string | number | (() => string | number) | undefined;
                    readonly falseLabel?: string | number | (() => string | number) | undefined;
                    readonly id?: string | (() => string) | undefined;
                    readonly border?: boolean | (() => boolean) | undefined;
                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
                    readonly tabindex?: string | number | (() => string | number) | undefined;
                    readonly validateEvent?: boolean | (() => boolean) | undefined;
                    readonly ariaLabel?: string | (() => string) | undefined;
                    readonly ariaControls?: string | (() => string) | undefined;
                }) => void;
            } & {
                CheckboxButton: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                        "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                        change: (val: import("element-plus").CheckboxValueType) => void;
                    }, import("vue").PublicProps, {
                        modelValue: number | string | boolean;
                        label: string | boolean | number | object;
                        disabled: boolean;
                        value: string | boolean | number | object;
                        name: string;
                        trueValue: string | number;
                        falseValue: string | number;
                        trueLabel: string | number;
                        falseLabel: string | number;
                        id: string;
                        validateEvent: boolean;
                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("element-plus").CheckboxProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    }>, {}, {}, {}, {}, {
                        modelValue: number | string | boolean;
                        label: string | boolean | number | object;
                        disabled: boolean;
                        value: string | boolean | number | object;
                        name: string;
                        trueValue: string | number;
                        falseValue: string | number;
                        trueLabel: string | number;
                        falseLabel: string | number;
                        id: string;
                        validateEvent: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").CheckboxProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    "update:modelValue": (val: import("element-plus").CheckboxValueType) => void;
                    change: (val: import("element-plus").CheckboxValueType) => void;
                }, string, {
                    modelValue: number | string | boolean;
                    label: string | boolean | number | object;
                    disabled: boolean;
                    value: string | boolean | number | object;
                    name: string;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                    id: string;
                    validateEvent: boolean;
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                    $slots: {
                        default?: (props: {}) => any;
                    };
                });
                CheckboxGroup: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").CheckboxGroupProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                        "update:modelValue": (val: import("element-plus").CheckboxGroupValueType) => void;
                        change: (val: import("element-plus").CheckboxValueType[]) => void;
                    }, import("vue").PublicProps, {
                        props: {
                            value?: string;
                            label?: string;
                            disabled?: string;
                        };
                        type: "checkbox" | "button";
                        modelValue: import("element-plus").CheckboxGroupValueType;
                        tag: string;
                        disabled: boolean;
                        validateEvent: boolean;
                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("element-plus").CheckboxGroupProps> & Readonly<{
                        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
                        onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
                    }>, {}, {}, {}, {}, {
                        props: {
                            value?: string;
                            label?: string;
                            disabled?: string;
                        };
                        type: "checkbox" | "button";
                        modelValue: import("element-plus").CheckboxGroupValueType;
                        tag: string;
                        disabled: boolean;
                        validateEvent: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").CheckboxGroupProps> & Readonly<{
                    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
                    onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    "update:modelValue": (val: import("element-plus").CheckboxGroupValueType) => void;
                    change: (val: import("element-plus").CheckboxValueType[]) => void;
                }, string, {
                    props: {
                        value?: string;
                        label?: string;
                        disabled?: string;
                    };
                    type: "checkbox" | "button";
                    modelValue: import("element-plus").CheckboxGroupValueType;
                    tag: string;
                    disabled: boolean;
                    validateEvent: boolean;
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                    $slots: {
                        default?: (props: {}) => any;
                    };
                });
            };
            NodeContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                node: {
                    type: ObjectConstructor;
                    required: true;
                };
                renderContent: FunctionConstructor;
            }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                node: {
                    type: ObjectConstructor;
                    required: true;
                };
                renderContent: FunctionConstructor;
            }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            ElIcon: import("element-plus/es/utils/index.mjs").SFCWithInstall<{
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                $slots: {
                    default?: (props: {}) => any;
                };
            })>;
            Loading: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        readonly data: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData) | (((new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
        readonly emptyText: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly nodeKey: StringConstructor;
        readonly checkStrictly: BooleanConstructor;
        readonly defaultExpandAll: BooleanConstructor;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkOnClickNode: BooleanConstructor;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly checkDescendants: BooleanConstructor;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly defaultCheckedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly defaultExpandedKeys: {
            readonly type: import("vue").PropType<TreeKey[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly currentNodeKey: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly renderContent: {
            readonly type: import("vue").PropType<import("element-plus").RenderContentFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly showCheckbox: BooleanConstructor;
        readonly draggable: BooleanConstructor;
        readonly allowDrag: {
            readonly type: import("vue").PropType<import("element-plus").AllowDragFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly allowDrop: {
            readonly type: import("vue").PropType<import("element-plus").AllowDropFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps) | (((new (...args: any[]) => import("element-plus").TreeOptionProps) | (() => import("element-plus").TreeOptionProps)) | null)[], unknown, unknown, () => {
            children: string;
            label: string;
            disabled: string;
        }, boolean>;
        readonly lazy: BooleanConstructor;
        readonly highlightCurrent: BooleanConstructor;
        readonly load: {
            readonly type: import("vue").PropType<import("element-plus").LoadFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly filterNodeMethod: {
            readonly type: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly accordion: BooleanConstructor;
        readonly indent: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
        readonly icon: {
            readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>> & Readonly<{
        "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
        "onNode-expand"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
        "onNode-click"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null, evt: MouseEvent) => any) | undefined;
        "onNode-contextmenu"?: ((evt: Event, data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        "onNode-collapse"?: ((data: any, node: Node, nodeInstance: import("vue").ComponentInternalInstance | null) => any) | undefined;
        onCheck?: ((data: any, checkedInfo: import("element-plus").CheckedInfo) => any) | undefined;
        "onNode-drag-start"?: ((node: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-end"?: ((draggingNode: Node, dropNode: Node | null, dropType: import("element-plus").NodeDropType, evt: DragEvent) => any) | undefined;
        "onNode-drop"?: ((draggingNode: Node, dropNode: Node, dropType: "after" | "before" | "inner", evt: DragEvent) => any) | undefined;
        "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
        "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
    }>, {
        ns: {
            namespace: import("vue").ComputedRef<string>;
            b: (blockSuffix?: string) => string;
            e: (element?: string) => string;
            m: (modifier?: string) => string;
            be: (blockSuffix?: string, element?: string) => string;
            em: (element?: string, modifier?: string) => string;
            bm: (blockSuffix?: string, modifier?: string) => string;
            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
            is: {
                (name: string, state: boolean | undefined): string;
                (name: string): string;
            };
            cssVar: (object: Record<string, string>) => Record<string, string>;
            cssVarName: (name: string) => string;
            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
            cssVarBlockName: (name: string) => string;
        };
        store: import("vue").Ref<{
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }, import("element-plus/es/components/tree/src/model/tree-store.mjs").default | {
            currentNode: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            } | null;
            currentNodeKey: TreeKey | null;
            nodesMap: import("element-plus").TreeStoreNodesMap;
            root: {
                id: number;
                text: string | null;
                checked: boolean;
                indeterminate: boolean;
                data: TreeNodeData;
                expanded: boolean;
                parent: any | null;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean | undefined;
                isLeaf: boolean | undefined;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                isEffectivelyChecked: boolean;
                initialize: () => void;
                setData: (data: TreeNodeData) => void;
                readonly label: string;
                readonly key: TreeKey | null | undefined;
                readonly disabled: boolean;
                readonly nextSibling: any | null;
                readonly previousSibling: any | null;
                contains: (target: Node, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                removeChild: (child: Node) => void;
                removeChildByData: (data: TreeNodeData | null) => void;
                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                updateChildren: () => void;
                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                eachNode: (callback: (node: Node) => void) => void;
                reInitChecked: () => void;
            };
            data: TreeNodeData[];
            lazy: boolean;
            load?: import("element-plus").LoadFunction | undefined;
            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
            key: TreeKey;
            defaultCheckedKeys?: TreeKey[] | undefined;
            checkStrictly: boolean;
            defaultExpandedKeys?: TreeKey[] | undefined;
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children?: string | undefined;
                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                class?: ((data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                }) | undefined;
            };
            initialize: () => void;
            filter: (value: import("element-plus").FilterValue) => void;
            setData: (newVal: import("element-plus").TreeData) => void;
            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
            remove: (data: TreeNodeData | Node) => void;
            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: Node) => void;
            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
            registerNode: (node: Node) => void;
            deregisterNode: (node: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            _getAllNodes: () => Node[];
            updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node | null;
            setCurrentNode: (currentNode: Node) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        }>;
        root: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        }>;
        currentNode: import("vue").Ref<{
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null, Node | {
            id: number;
            text: string | null;
            checked: boolean;
            indeterminate: boolean;
            data: TreeNodeData;
            expanded: boolean;
            parent: any | null;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any | null;
                currentNodeKey: TreeKey | null;
                nodesMap: import("element-plus").TreeStoreNodesMap;
                root: any;
                data: TreeNodeData[];
                lazy: boolean;
                load?: import("element-plus").LoadFunction | undefined;
                filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                key: TreeKey;
                defaultCheckedKeys?: TreeKey[] | undefined;
                checkStrictly: boolean;
                defaultExpandedKeys?: TreeKey[] | undefined;
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children?: string | undefined;
                    label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                    disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                    class?: ((data: TreeNodeData, node: Node) => string | {
                        [key: string]: boolean;
                    }) | undefined;
                };
                initialize: () => void;
                filter: (value: import("element-plus").FilterValue) => void;
                setData: (newVal: import("element-plus").TreeData) => void;
                getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                remove: (data: TreeNodeData | Node) => void;
                append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: Node) => void;
                setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                registerNode: (node: Node) => void;
                deregisterNode: (node: Node) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                getHalfCheckedNodes: () => TreeNodeData[];
                getHalfCheckedKeys: () => TreeKey[];
                _getAllNodes: () => Node[];
                updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => Node | null;
                setCurrentNode: (currentNode: Node) => void;
                setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean | undefined;
            isLeaf: boolean | undefined;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            isEffectivelyChecked: boolean;
            initialize: () => void;
            setData: (data: TreeNodeData) => void;
            readonly label: string;
            readonly key: TreeKey | null | undefined;
            readonly disabled: boolean;
            readonly nextSibling: any | null;
            readonly previousSibling: any | null;
            contains: (target: Node, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
            removeChild: (child: Node) => void;
            removeChildByData: (data: TreeNodeData | null) => void;
            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
            updateChildren: () => void;
            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
            eachNode: (callback: (node: Node) => void) => void;
            reInitChecked: () => void;
        } | null>;
        dragState: import("vue").Ref<{
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }, {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
            showDropIndicator: boolean;
            dropNode: import("element-plus/es/components/tree/src/model/useDragNode.mjs").TreeNode | null;
        } | {
            allowDrop: boolean;
            dropType: import("element-plus").NodeDropType | null;
            draggingNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
            showDropIndicator: boolean;
            dropNode: {
                node: {
                    id: number;
                    text: string | null;
                    checked: boolean;
                    indeterminate: boolean;
                    data: TreeNodeData;
                    expanded: boolean;
                    parent: any | null;
                    visible: boolean;
                    isCurrent: boolean;
                    store: {
                        currentNode: any | null;
                        currentNodeKey: TreeKey | null;
                        nodesMap: import("element-plus").TreeStoreNodesMap;
                        root: any;
                        data: TreeNodeData[];
                        lazy: boolean;
                        load?: import("element-plus").LoadFunction | undefined;
                        filterNodeMethod?: import("element-plus").FilterNodeMethodFunction | undefined;
                        key: TreeKey;
                        defaultCheckedKeys?: TreeKey[] | undefined;
                        checkStrictly: boolean;
                        defaultExpandedKeys?: TreeKey[] | undefined;
                        autoExpandParent: boolean;
                        defaultExpandAll: boolean;
                        checkDescendants: boolean;
                        props: {
                            children?: string | undefined;
                            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
                            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
                            class?: ((data: TreeNodeData, node: Node) => string | {
                                [key: string]: boolean;
                            }) | undefined;
                        };
                        initialize: () => void;
                        filter: (value: import("element-plus").FilterValue) => void;
                        setData: (newVal: import("element-plus").TreeData) => void;
                        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
                        remove: (data: TreeNodeData | Node) => void;
                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
                        _initDefaultCheckedNodes: () => void;
                        _initDefaultCheckedNode: (node: Node) => void;
                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
                        registerNode: (node: Node) => void;
                        deregisterNode: (node: Node) => void;
                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
                        getHalfCheckedNodes: () => TreeNodeData[];
                        getHalfCheckedKeys: () => TreeKey[];
                        _getAllNodes: () => Node[];
                        updateChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
                            [key: string]: boolean;
                        }) => void;
                        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
                        getCurrentNode: () => Node | null;
                        setCurrentNode: (currentNode: Node) => void;
                        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
                    };
                    isLeafByUser: boolean | undefined;
                    isLeaf: boolean | undefined;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    isEffectivelyChecked: boolean;
                    initialize: () => void;
                    setData: (data: TreeNodeData) => void;
                    readonly label: string;
                    readonly key: TreeKey | null | undefined;
                    readonly disabled: boolean;
                    readonly nextSibling: any | null;
                    readonly previousSibling: any | null;
                    contains: (target: Node, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus").FakeNode | Node, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    insertAfter: (child: import("element-plus").FakeNode | Node, ref: Node) => void;
                    removeChild: (child: Node) => void;
                    removeChildByData: (data: TreeNodeData | null) => void;
                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
                    updateChildren: () => void;
                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
                    eachNode: (callback: (node: Node) => void) => void;
                    reInitChecked: () => void;
                };
                $el?: HTMLElement | undefined;
            } | null;
        }>;
        el$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        dropIndicator$: import("vue").Ref<import("element-plus").Nullable<HTMLElement>, import("element-plus").Nullable<HTMLElement>>;
        isEmpty: import("vue").ComputedRef<boolean>;
        filter: (value: import("element-plus").FilterValue) => void;
        getNodeKey: (node: Node) => any;
        getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
        getCurrentNode: () => TreeNodeData | null;
        getCurrentKey: () => TreeKey | null;
        setCheckedNodes: (nodes: Node[], leafOnly?: boolean) => void;
        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep?: boolean) => void;
        getHalfCheckedNodes: () => TreeNodeData[];
        getHalfCheckedKeys: () => TreeKey[];
        setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
        setCurrentKey: (key?: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
        t: import("element-plus").Translator;
        getNode: (data: TreeKey | TreeNodeData) => Node;
        remove: (data: TreeNodeData | Node) => void;
        append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void;
        insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
        handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: import("vue").ComponentInternalInstance) => void;
        updateKeyChildren: (key: TreeKey, data: import("element-plus").TreeData) => void;
    }, {}, {}, {}, {
        readonly props: import("element-plus").TreeOptionProps;
        readonly data: import("element-plus").TreeData;
        readonly checkStrictly: boolean;
        readonly lazy: boolean;
        readonly checkOnClickNode: boolean;
        readonly checkOnClickLeaf: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly accordion: boolean;
        readonly draggable: boolean;
        readonly defaultExpandAll: boolean;
        readonly indent: number;
        readonly renderAfterExpand: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly showCheckbox: boolean;
        readonly expandOnClickNode: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly autoExpandParent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly checkDescendants: boolean;
        readonly highlightCurrent: boolean;
    }> | undefined>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
    "update:modelValue": (val: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[]) | (((new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[])) | null)[], unknown, unknown>) => any;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[]) | (((new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[])) | null)[], unknown, unknown, string, boolean>;
    bindObject: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    multiple: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    filterable: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    collapseTags: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    clearable: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    lazy: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    load: {
        readonly type: import("vue").PropType<import("element-plus").LoadFunction>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    checkStrictly: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    filterChildWhenSelectAll: {
        readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    placeholder: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    label: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown, string, boolean>;
    valueKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
    childrenKey: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
    disabled: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown, string, boolean>;
    isLeaf: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown, string, boolean>;
    data: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData) | (((new (...args: any[]) => import("element-plus").TreeData) | (() => import("element-plus").TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
    treeProps: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").TreeComponentProps>) | (() => Partial<import("element-plus").TreeComponentProps>) | (((new (...args: any[]) => Partial<import("element-plus").TreeComponentProps>) | (() => Partial<import("element-plus").TreeComponentProps>)) | null)[], unknown, unknown, () => {}, boolean>;
    selectProps: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").SelectProps>) | (() => Partial<import("element-plus").SelectProps>) | (((new (...args: any[]) => Partial<import("element-plus").SelectProps>) | (() => Partial<import("element-plus").SelectProps>)) | null)[], unknown, unknown, () => {}, boolean>;
}>> & Readonly<{
    "onUpdate:modelValue"?: ((val: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[]) | (((new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[])) | null)[], unknown, unknown>) => any) | undefined;
}>, {
    label: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown>;
    disabled: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown>;
    modelValue: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[]) | (((new (...args: any[]) => string | number | TreeNodeData | SelectTreeBaseModelValue[]) | (() => SelectTreeBaseModelValue | SelectTreeBaseModelValue[])) | null)[], unknown, unknown>;
    valueKey: string;
    data: import("element-plus").TreeData;
    childrenKey: string;
    isLeaf: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string)) | (((new (...args: any[]) => string | ((data: TreeNodeData) => string)) | (() => string | ((data: TreeNodeData) => string))) | null)[], unknown, unknown>;
    treeProps: Partial<import("element-plus").TreeComponentProps>;
    selectProps: Partial<import("element-plus").SelectProps>;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
    'tree-node'?: (props: any) => any;
}>;
type __VLS_WithSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};