import { App } from 'vue';
import { ArcoOptions } from '../_utils/types';
import _TreeSelect from './tree-select';
declare const TreeSelect: {
    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        disabled: {
            type: BooleanConstructor;
        };
        loading: {
            type: BooleanConstructor;
        };
        error: {
            type: BooleanConstructor;
        };
        size: {
            type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
        };
        border: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowSearch: {
            type: import("vue").PropType<boolean | {
                retainInputValue?: boolean | undefined;
            }>;
            default: (props: import("../_utils/types").Data) => boolean;
        };
        allowClear: {
            type: BooleanConstructor;
        };
        placeholder: {
            type: StringConstructor;
        };
        maxTagCount: {
            type: NumberConstructor;
        };
        multiple: {
            type: BooleanConstructor;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[]>;
        };
        modelValue: {
            type: import("vue").PropType<string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[]>;
        };
        fieldNames: {
            type: import("vue").PropType<import("..").TreeFieldNames>;
        };
        data: {
            type: import("vue").PropType<import("..").TreeNodeData[]>;
            default: () => never[];
        };
        labelInValue: {
            type: BooleanConstructor;
        };
        treeCheckable: {
            type: BooleanConstructor;
        };
        treeCheckStrictly: {
            type: BooleanConstructor;
        };
        treeCheckedStrategy: {
            type: import("vue").PropType<"all" | "child" | "parent">;
            default: string;
        };
        treeProps: {
            type: import("vue").PropType<Partial<import("../tree/interface").TreeProps>>;
        };
        triggerProps: {
            type: import("vue").PropType<Partial<import("..").TriggerProps>>;
        };
        popupVisible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultPopupVisible: {
            type: BooleanConstructor;
        };
        dropdownStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        dropdownClassName: {
            type: import("vue").PropType<string | string[]>;
        };
        filterTreeNode: {
            type: import("vue").PropType<(searchKey: string, nodeData: import("..").TreeNodeData) => boolean>;
        };
        loadMore: {
            type: import("vue").PropType<(nodeData: import("..").TreeNodeData) => Promise<void>>;
        };
        disableFilter: {
            type: BooleanConstructor;
        };
        popupContainer: {
            type: import("vue").PropType<string | HTMLElement>;
        };
        fallbackOption: {
            type: import("vue").PropType<boolean | ((key: string | number) => boolean | import("..").TreeNodeData)>;
            default: boolean;
        };
        selectable: {
            type: import("vue").PropType<boolean | "leaf" | ((node: import("..").TreeNodeData, info: {
                isLeaf: boolean;
                level: number;
            }) => boolean)>;
            default: boolean;
        };
        scrollbar: {
            type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
            default: boolean;
        };
        showHeaderOnEmpty: {
            type: import("vue").PropType<boolean>;
            default: boolean;
        };
        showFooterOnEmpty: {
            type: import("vue").PropType<boolean>;
            default: boolean;
        };
        inputValue: {
            type: StringConstructor;
        };
        defaultInputValue: {
            type: StringConstructor;
            default: string;
        };
    }>> & Readonly<{
        onClear?: (() => any) | undefined;
        onChange?: ((value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => any) | undefined;
        "onUpdate:inputValue"?: ((inputValue: string) => any) | undefined;
        onInputValueChange?: ((inputValue: string) => any) | undefined;
        "onUpdate:modelValue"?: ((value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => any) | undefined;
        "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
        onSearch?: ((searchKey: string) => any) | undefined;
        "onPopup-visible-change"?: ((visible: boolean) => any) | undefined;
    }>, {
        refSelectView: import("vue").Ref<any, any>;
        prefixCls: string;
        TreeSelectEmpty: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | undefined;
        selectedValue: import("vue").ComputedRef<import("./interface").LabelValue[]>;
        selectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
        mergedDisabled: import("vue").ComputedRef<boolean>;
        searchValue: import("vue").ComputedRef<string>;
        panelVisible: import("vue").ComputedRef<boolean>;
        isEmpty: import("vue").ComputedRef<boolean | undefined>;
        computedFilterTreeNode: import("vue").ComputedRef<((node: import("..").TreeNodeData) => boolean) | undefined>;
        isMultiple: import("vue").ComputedRef<boolean>;
        selectViewValue: import("vue").ComputedRef<import("../_components/select-view/interface").SelectViewValue[]>;
        computedDropdownStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
        onSearchValueChange: (inputValue: string) => void;
        onSelectChange(newVal: string[]): void;
        onVisibleChange: (visible: boolean) => void;
        onInnerClear(): void;
        pickSubCompSlots: typeof import("../_utils/pick-sub-comp-slots").default;
        isSelectable: (node: import("..").TreeNodeData, info: {
            level: number;
            isLeaf: boolean;
        }) => boolean;
        isCheckable: import("vue").ComputedRef<false | ((node: import("..").TreeNodeData, info: {
            level: number;
            isLeaf: boolean;
        }) => boolean)>;
        onBlur: () => void;
        onItemRemove(id: string): void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        change: (value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => true;
        'update:modelValue': (value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => true;
        'update:inputValue': (inputValue: string) => true;
        'popup-visible-change': (visible: boolean) => true;
        'update:popupVisible': (visible: boolean) => true;
        search: (searchKey: string) => true;
        clear: () => true;
        inputValueChange: (inputValue: string) => true;
    }, import("vue").PublicProps, {
        disabled: boolean;
        error: boolean;
        allowClear: boolean;
        data: import("..").TreeNodeData[];
        loading: boolean;
        multiple: boolean;
        allowSearch: boolean | {
            retainInputValue?: boolean | undefined;
        };
        defaultInputValue: string;
        scrollbar: boolean | import("..").ScrollbarProps;
        border: boolean;
        popupVisible: boolean;
        defaultPopupVisible: boolean;
        fallbackOption: boolean | ((key: string | number) => boolean | import("..").TreeNodeData);
        showHeaderOnEmpty: boolean;
        showFooterOnEmpty: boolean;
        selectable: boolean | "leaf" | ((node: import("..").TreeNodeData, info: {
            isLeaf: boolean;
            level: number;
        }) => boolean);
        labelInValue: boolean;
        treeCheckable: boolean;
        treeCheckStrictly: boolean;
        treeCheckedStrategy: "all" | "child" | "parent";
        disableFilter: boolean;
    }, true, {}, {}, {
        Trigger: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                popupVisible: {
                    type: BooleanConstructor;
                    default: undefined;
                };
                defaultPopupVisible: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                trigger: {
                    type: import("vue").PropType<"focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[]>;
                    default: string;
                };
                position: {
                    type: import("vue").PropType<"br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popupOffset: {
                    type: NumberConstructor;
                    default: number;
                };
                popupTranslate: {
                    type: import("vue").PropType<import("..").TriggerPopupTranslate>;
                };
                showArrow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                alignPoint: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popupHoverStay: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                blurToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                clickToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                clickOutsideToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                unmountOnClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                contentClass: {
                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                };
                contentStyle: {
                    type: import("vue").PropType<import("vue").CSSProperties>;
                };
                arrowClass: {
                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                };
                arrowStyle: {
                    type: import("vue").PropType<import("vue").CSSProperties>;
                };
                popupStyle: {
                    type: import("vue").PropType<import("vue").CSSProperties>;
                };
                animationName: {
                    type: StringConstructor;
                    default: string;
                };
                duration: {
                    type: import("vue").PropType<number | {
                        enter: number;
                        leave: number;
                    }>;
                };
                mouseEnterDelay: {
                    type: NumberConstructor;
                    default: number;
                };
                mouseLeaveDelay: {
                    type: NumberConstructor;
                    default: number;
                };
                focusDelay: {
                    type: NumberConstructor;
                    default: number;
                };
                autoFitPopupWidth: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                autoFitPopupMinWidth: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                autoFixPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popupContainer: {
                    type: import("vue").PropType<string | HTMLElement>;
                };
                updateAtScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                autoFitTransformOrigin: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideEmpty: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                openedClass: {
                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                };
                autoFitPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                renderToBody: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                preventFocus: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                scrollToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                scrollToCloseDistance: {
                    type: NumberConstructor;
                    default: number;
                };
            }>> & Readonly<{
                onResize?: (() => any) | undefined;
                onHide?: (() => any) | undefined;
                onShow?: (() => any) | undefined;
                "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
                onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                'update:popupVisible': (visible: boolean) => true;
                popupVisibleChange: (visible: boolean) => true;
                show: () => true;
                hide: () => true;
                resize: () => true;
            }, import("vue").PublicProps, {
                disabled: boolean;
                position: "br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb";
                popupVisible: boolean;
                defaultPopupVisible: boolean;
                trigger: "focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[];
                popupOffset: number;
                showArrow: boolean;
                alignPoint: boolean;
                popupHoverStay: boolean;
                blurToClose: boolean;
                clickToClose: boolean;
                clickOutsideToClose: boolean;
                unmountOnClose: boolean;
                animationName: string;
                mouseEnterDelay: number;
                mouseLeaveDelay: number;
                focusDelay: number;
                autoFitPopupWidth: boolean;
                autoFitPopupMinWidth: boolean;
                autoFixPosition: boolean;
                updateAtScroll: boolean;
                autoFitTransformOrigin: boolean;
                hideEmpty: boolean;
                autoFitPosition: boolean;
                renderToBody: boolean;
                preventFocus: boolean;
                scrollToClose: boolean;
                scrollToCloseDistance: number;
            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                popupVisible: {
                    type: BooleanConstructor;
                    default: undefined;
                };
                defaultPopupVisible: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                trigger: {
                    type: import("vue").PropType<"focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[]>;
                    default: string;
                };
                position: {
                    type: import("vue").PropType<"br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popupOffset: {
                    type: NumberConstructor;
                    default: number;
                };
                popupTranslate: {
                    type: import("vue").PropType<import("..").TriggerPopupTranslate>;
                };
                showArrow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                alignPoint: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popupHoverStay: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                blurToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                clickToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                clickOutsideToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                unmountOnClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                contentClass: {
                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                };
                contentStyle: {
                    type: import("vue").PropType<import("vue").CSSProperties>;
                };
                arrowClass: {
                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                };
                arrowStyle: {
                    type: import("vue").PropType<import("vue").CSSProperties>;
                };
                popupStyle: {
                    type: import("vue").PropType<import("vue").CSSProperties>;
                };
                animationName: {
                    type: StringConstructor;
                    default: string;
                };
                duration: {
                    type: import("vue").PropType<number | {
                        enter: number;
                        leave: number;
                    }>;
                };
                mouseEnterDelay: {
                    type: NumberConstructor;
                    default: number;
                };
                mouseLeaveDelay: {
                    type: NumberConstructor;
                    default: number;
                };
                focusDelay: {
                    type: NumberConstructor;
                    default: number;
                };
                autoFitPopupWidth: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                autoFitPopupMinWidth: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                autoFixPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popupContainer: {
                    type: import("vue").PropType<string | HTMLElement>;
                };
                updateAtScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                autoFitTransformOrigin: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideEmpty: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                openedClass: {
                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                };
                autoFitPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                renderToBody: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                preventFocus: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                scrollToClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                scrollToCloseDistance: {
                    type: NumberConstructor;
                    default: number;
                };
            }>> & Readonly<{
                onResize?: (() => any) | undefined;
                onHide?: (() => any) | undefined;
                onShow?: (() => any) | undefined;
                "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
                onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                disabled: boolean;
                position: "br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb";
                popupVisible: boolean;
                defaultPopupVisible: boolean;
                trigger: "focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[];
                popupOffset: number;
                showArrow: boolean;
                alignPoint: boolean;
                popupHoverStay: boolean;
                blurToClose: boolean;
                clickToClose: boolean;
                clickOutsideToClose: boolean;
                unmountOnClose: boolean;
                animationName: string;
                mouseEnterDelay: number;
                mouseLeaveDelay: number;
                focusDelay: number;
                autoFitPopupWidth: boolean;
                autoFitPopupMinWidth: boolean;
                autoFixPosition: boolean;
                updateAtScroll: boolean;
                autoFitTransformOrigin: boolean;
                hideEmpty: boolean;
                autoFitPosition: boolean;
                renderToBody: boolean;
                preventFocus: boolean;
                scrollToClose: boolean;
                scrollToCloseDistance: number;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            popupVisible: {
                type: BooleanConstructor;
                default: undefined;
            };
            defaultPopupVisible: {
                type: BooleanConstructor;
                default: boolean;
            };
            trigger: {
                type: import("vue").PropType<"focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[]>;
                default: string;
            };
            position: {
                type: import("vue").PropType<"br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb">;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupOffset: {
                type: NumberConstructor;
                default: number;
            };
            popupTranslate: {
                type: import("vue").PropType<import("..").TriggerPopupTranslate>;
            };
            showArrow: {
                type: BooleanConstructor;
                default: boolean;
            };
            alignPoint: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupHoverStay: {
                type: BooleanConstructor;
                default: boolean;
            };
            blurToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            clickToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            clickOutsideToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            unmountOnClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            contentClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            contentStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            arrowClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            arrowStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            popupStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            animationName: {
                type: StringConstructor;
                default: string;
            };
            duration: {
                type: import("vue").PropType<number | {
                    enter: number;
                    leave: number;
                }>;
            };
            mouseEnterDelay: {
                type: NumberConstructor;
                default: number;
            };
            mouseLeaveDelay: {
                type: NumberConstructor;
                default: number;
            };
            focusDelay: {
                type: NumberConstructor;
                default: number;
            };
            autoFitPopupWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFitPopupMinWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFixPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupContainer: {
                type: import("vue").PropType<string | HTMLElement>;
            };
            updateAtScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFitTransformOrigin: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideEmpty: {
                type: BooleanConstructor;
                default: boolean;
            };
            openedClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            autoFitPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
            renderToBody: {
                type: BooleanConstructor;
                default: boolean;
            };
            preventFocus: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollToCloseDistance: {
                type: NumberConstructor;
                default: number;
            };
        }>> & Readonly<{
            onResize?: (() => any) | undefined;
            onHide?: (() => any) | undefined;
            onShow?: (() => any) | undefined;
            "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
            onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            'update:popupVisible': (visible: boolean) => true;
            popupVisibleChange: (visible: boolean) => true;
            show: () => true;
            hide: () => true;
            resize: () => true;
        }, string, {
            disabled: boolean;
            position: "br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb";
            popupVisible: boolean;
            defaultPopupVisible: boolean;
            trigger: "focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[];
            popupOffset: number;
            showArrow: boolean;
            alignPoint: boolean;
            popupHoverStay: boolean;
            blurToClose: boolean;
            clickToClose: boolean;
            clickOutsideToClose: boolean;
            unmountOnClose: boolean;
            animationName: string;
            mouseEnterDelay: number;
            mouseLeaveDelay: number;
            focusDelay: number;
            autoFitPopupWidth: boolean;
            autoFitPopupMinWidth: boolean;
            autoFixPosition: boolean;
            updateAtScroll: boolean;
            autoFitTransformOrigin: boolean;
            hideEmpty: boolean;
            autoFitPosition: boolean;
            renderToBody: boolean;
            preventFocus: boolean;
            scrollToClose: boolean;
            scrollToCloseDistance: number;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
        SelectView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            modelValue: {
                type: import("vue").PropType<import("../_components/select-view/interface").SelectViewValue[]>;
                required: true;
            };
            inputValue: StringConstructor;
            placeholder: StringConstructor;
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            error: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            opened: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            bordered: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            allowClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            allowCreate: {
                type: BooleanConstructor;
                default: boolean;
            };
            allowSearch: {
                type: BooleanConstructor;
                default: (props: import("../_utils/types").Data) => boolean;
            };
            maxTagCount: {
                type: NumberConstructor;
                default: number;
            };
            tagNowrap: {
                type: BooleanConstructor;
                default: boolean;
            };
            retainInputValue: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            inputRef: import("vue").ComputedRef<HTMLInputElement>;
            handleFocus: (ev: FocusEvent) => void;
            handleBlur: (ev: FocusEvent) => void;
            render: () => import("vue/jsx-runtime").JSX.Element;
        }, {}, {}, {
            focus(): void;
            blur(): void;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "blur" | "focus" | "remove")[], "clear" | "blur" | "focus" | "remove", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            modelValue: {
                type: import("vue").PropType<import("../_components/select-view/interface").SelectViewValue[]>;
                required: true;
            };
            inputValue: StringConstructor;
            placeholder: StringConstructor;
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            error: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            opened: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            bordered: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            allowClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            allowCreate: {
                type: BooleanConstructor;
                default: boolean;
            };
            allowSearch: {
                type: BooleanConstructor;
                default: (props: import("../_utils/types").Data) => boolean;
            };
            maxTagCount: {
                type: NumberConstructor;
                default: number;
            };
            tagNowrap: {
                type: BooleanConstructor;
                default: boolean;
            };
            retainInputValue: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onClear?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onFocus?: ((...args: any[]) => any) | undefined;
            onRemove?: ((...args: any[]) => any) | undefined;
        }>, {
            disabled: boolean;
            error: boolean;
            allowClear: boolean;
            retainInputValue: boolean;
            loading: boolean;
            opened: boolean;
            bordered: boolean;
            multiple: boolean;
            allowCreate: boolean;
            allowSearch: boolean;
            maxTagCount: number;
            tagNowrap: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        Panel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            treeProps: {
                type: import("vue").PropType<Partial<import("../tree/interface").TreeProps>>;
                default: () => {};
            };
            selectedKeys: {
                type: import("vue").PropType<import("../tree/interface").TreeNodeKey[]>;
            };
            showCheckable: {
                type: BooleanConstructor;
            };
            treeSlots: {
                type: import("vue").PropType<Readonly<{
                    [name: string]: import("vue").Slot<any> | undefined;
                }>>;
                default: () => {};
            };
            scrollbar: {
                type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                default: boolean;
            };
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            treeProps: {
                type: import("vue").PropType<Partial<import("../tree/interface").TreeProps>>;
                default: () => {};
            };
            selectedKeys: {
                type: import("vue").PropType<import("../tree/interface").TreeNodeKey[]>;
            };
            showCheckable: {
                type: BooleanConstructor;
            };
            treeSlots: {
                type: import("vue").PropType<Readonly<{
                    [name: string]: import("vue").Slot<any> | undefined;
                }>>;
                default: () => {};
            };
            scrollbar: {
                type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                default: boolean;
            };
        }>> & Readonly<{
            onChange?: ((...args: any[]) => any) | undefined;
        }>, {
            scrollbar: boolean | import("..").ScrollbarProps;
            treeProps: Partial<import("../tree/interface").TreeProps>;
            showCheckable: boolean;
            treeSlots: Readonly<{
                [name: string]: import("vue").Slot<any> | undefined;
            }>;
        }, {}, {
            Tree: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    size: {
                        type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                        default: string;
                    };
                    blockNode: {
                        type: BooleanConstructor;
                    };
                    defaultExpandAll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                    };
                    checkable: {
                        type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean)>;
                        default: boolean;
                    };
                    selectable: {
                        type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean)>;
                        default: boolean;
                    };
                    checkStrictly: {
                        type: BooleanConstructor;
                    };
                    checkedStrategy: {
                        type: import("vue").PropType<"all" | "child" | "parent">;
                        default: string;
                    };
                    defaultSelectedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    selectedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    defaultCheckedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    checkedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    defaultExpandedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    expandedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    data: {
                        type: import("vue").PropType<import("..").TreeNodeData[]>;
                        default: () => never[];
                    };
                    fieldNames: {
                        type: import("vue").PropType<import("..").TreeFieldNames>;
                    };
                    showLine: {
                        type: BooleanConstructor;
                    };
                    loadMore: {
                        type: import("vue").PropType<(node: import("..").TreeNodeData) => Promise<void>>;
                    };
                    draggable: {
                        type: BooleanConstructor;
                    };
                    allowDrop: {
                        type: import("vue").PropType<(options: {
                            dropNode: import("..").TreeNodeData;
                            dropPosition: 0 | 1 | -1;
                        }) => boolean>;
                    };
                    filterTreeNode: {
                        type: import("vue").PropType<import("../tree/interface").FilterTreeNode>;
                    };
                    searchValue: {
                        type: StringConstructor;
                        default: string;
                    };
                    virtualListProps: {
                        type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                    };
                    defaultExpandSelected: {
                        type: BooleanConstructor;
                    };
                    defaultExpandChecked: {
                        type: BooleanConstructor;
                    };
                    autoExpandParent: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    halfCheckedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    onlyCheckLeaf: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    animation: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    actionOnNodeClick: {
                        type: import("vue").PropType<"expand">;
                    };
                    disableSelectActionOnly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onSelect?: ((selectedKeys: (string | number)[], data: {
                        selected?: boolean | undefined;
                        selectedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    onDrop?: ((data: {
                        e: DragEvent;
                        dragNode: import("..").TreeNodeData;
                        dropNode: import("..").TreeNodeData;
                        dropPosition: number;
                    }) => any) | undefined;
                    "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
                    "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
                    onExpand?: ((expandKeys: (string | number)[], data: {
                        expanded?: boolean | undefined;
                        expandedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    onCheck?: ((checkedKeys: (string | number)[], data: {
                        checked?: boolean | undefined;
                        checkedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        halfCheckedKeys: (string | number)[];
                        halfCheckedNodes: import("..").TreeNodeData[];
                        e?: Event | undefined;
                    }) => any) | undefined;
                    onDragStart?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    onDragOver?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    onDragLeave?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    onDragEnd?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
                    "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                }>, {
                    classNames: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                    })[]>;
                    visibleTreeNodeList: import("vue").ComputedRef<import("../tree/interface").Node[]>;
                    treeContext: {
                        treeProps: {
                            readonly size: "mini" | "small" | "medium" | "large";
                            readonly data: {
                                key?: string | number | undefined;
                                title?: string | undefined;
                                selectable?: boolean | undefined;
                                disabled?: boolean | undefined;
                                disableCheckbox?: boolean | undefined;
                                checkable?: boolean | undefined;
                                draggable?: boolean | undefined;
                                isLeaf?: boolean | undefined;
                                icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                children?: any[] | undefined;
                            }[];
                            readonly multiple: boolean;
                            readonly animation: boolean;
                            readonly draggable: boolean;
                            readonly checkStrictly: boolean;
                            readonly checkable: boolean | ((node: import("..").TreeNodeData, info: {
                                level: number;
                                isLeaf: boolean;
                            }) => boolean);
                            readonly showLine: boolean;
                            readonly selectable: boolean | ((node: import("..").TreeNodeData, info: {
                                level: number;
                                isLeaf: boolean;
                            }) => boolean);
                            readonly blockNode: boolean;
                            readonly defaultExpandAll: boolean;
                            readonly checkedStrategy: "all" | "child" | "parent";
                            readonly searchValue: string;
                            readonly defaultExpandSelected: boolean;
                            readonly defaultExpandChecked: boolean;
                            readonly autoExpandParent: boolean;
                            readonly onlyCheckLeaf: boolean;
                            readonly disableSelectActionOnly: boolean;
                            readonly fieldNames: {
                                key?: string | undefined;
                                title?: string | undefined;
                                disabled?: string | undefined;
                                children?: string | undefined;
                                isLeaf?: string | undefined;
                                disableCheckbox?: string | undefined;
                                checkable?: string | undefined;
                                icon?: string | undefined;
                            } | undefined;
                            readonly virtualListProps: {
                                height?: string | number | undefined;
                                threshold?: number | undefined;
                                isStaticItemHeight?: boolean | undefined;
                                fixedSize?: boolean | undefined;
                                estimatedSize?: number | undefined;
                                buffer?: number | undefined;
                                data?: unknown[] | undefined;
                                itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
                                component?: keyof HTMLElementTagNameMap | undefined;
                            } | undefined;
                            readonly loadMore: ((node: import("..").TreeNodeData) => Promise<void>) | undefined;
                            readonly selectedKeys: (string | number)[] | undefined;
                            readonly defaultSelectedKeys: (string | number)[] | undefined;
                            readonly expandedKeys: (string | number)[] | undefined;
                            readonly defaultExpandedKeys: (string | number)[] | undefined;
                            readonly checkedKeys: (string | number)[] | undefined;
                            readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                            readonly allowDrop: ((options: {
                                dropNode: import("..").TreeNodeData;
                                dropPosition: 0 | 1 | -1;
                            }) => boolean) | undefined;
                            readonly defaultCheckedKeys: (string | number)[] | undefined;
                            readonly halfCheckedKeys: (string | number)[] | undefined;
                            readonly actionOnNodeClick: "expand" | undefined;
                            readonly onSelect: ((selectedKeys: (string | number)[], data: {
                                selected?: boolean | undefined;
                                selectedNodes: import("..").TreeNodeData[];
                                node?: import("..").TreeNodeData | undefined;
                                e?: Event | undefined;
                            }) => any) | undefined;
                            readonly onDrop: ((data: {
                                e: DragEvent;
                                dragNode: import("..").TreeNodeData;
                                dropNode: import("..").TreeNodeData;
                                dropPosition: number;
                            }) => any) | undefined;
                            readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
                            readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
                            readonly onExpand: ((expandKeys: (string | number)[], data: {
                                expanded?: boolean | undefined;
                                expandedNodes: import("..").TreeNodeData[];
                                node?: import("..").TreeNodeData | undefined;
                                e?: Event | undefined;
                            }) => any) | undefined;
                            readonly onCheck: ((checkedKeys: (string | number)[], data: {
                                checked?: boolean | undefined;
                                checkedNodes: import("..").TreeNodeData[];
                                node?: import("..").TreeNodeData | undefined;
                                halfCheckedKeys: (string | number)[];
                                halfCheckedNodes: import("..").TreeNodeData[];
                                e?: Event | undefined;
                            }) => any) | undefined;
                            readonly onDragStart: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly onDragOver: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly onDragLeave: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly onDragEnd: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
                            readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                        };
                        switcherIcon: import("vue").Slot<any> | undefined;
                        loadingIcon: import("vue").Slot<any> | undefined;
                        dragIcon: import("vue").Slot<any> | undefined;
                        nodeIcon: import("vue").Slot<any> | undefined;
                        nodeTitle: import("vue").Slot<any> | undefined;
                        nodeExtra: import("vue").Slot<any> | undefined;
                        treeData: {
                            key: import("../tree/interface").TreeNodeKey;
                            treeNodeProps: {
                                selectable: boolean;
                                disabled: boolean;
                                disableCheckbox: boolean;
                                checkable: boolean;
                                draggable: boolean;
                                isLeaf: boolean;
                                isTail: boolean;
                                blockNode: boolean;
                                showLine: boolean;
                                level: number;
                                lineless: boolean[];
                                title?: string | undefined;
                                key?: string | number | undefined;
                                icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                            };
                            treeNodeData: {
                                key?: string | number | undefined;
                                title?: string | undefined;
                                selectable?: boolean | undefined;
                                disabled?: boolean | undefined;
                                disableCheckbox?: boolean | undefined;
                                checkable?: boolean | undefined;
                                draggable?: boolean | undefined;
                                isLeaf?: boolean | undefined;
                                icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                children?: any[] | undefined;
                            };
                            parent?: any | undefined;
                            parentKey?: import("../tree/interface").TreeNodeKey | undefined;
                            pathParentKeys: import("../tree/interface").TreeNodeKey[];
                            children?: any[] | undefined;
                            selectable: boolean;
                            disabled: boolean;
                            disableCheckbox: boolean;
                            checkable: boolean;
                            draggable: boolean;
                            isLeaf: boolean;
                            isTail: boolean;
                            blockNode: boolean;
                            showLine: boolean;
                            level: number;
                            lineless: boolean[];
                            title?: string | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                        }[];
                        flattenTreeData: import("../tree/interface").Node[];
                        key2TreeNode: import("../tree/interface").Key2TreeNode;
                        checkedKeys: import("../tree/interface").TreeNodeKey[];
                        indeterminateKeys: import("../tree/interface").TreeNodeKey[];
                        selectedKeys: import("../tree/interface").TreeNodeKey[];
                        expandedKeys: import("../tree/interface").TreeNodeKey[];
                        loadingKeys: import("../tree/interface").TreeNodeKey[];
                        currentExpandKeys: import("../tree/interface").TreeNodeKey[];
                        onLoadMore: ((key: import("../tree/interface").TreeNodeKey) => Promise<void>) | undefined;
                        filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                        onCheck: (checked: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                        onSelect: (key: import("../tree/interface").TreeNodeKey, e: Event) => void;
                        onExpand: (expanded: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                        onExpandEnd: (key: import("../tree/interface").TreeNodeKey) => void;
                        allowDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                        onDragStart: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDragEnd: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDragOver: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDragLeave: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: number, e: DragEvent) => void;
                    };
                    virtualListRef: import("vue").Ref<any, any>;
                    computedSelectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    computedExpandedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    computedCheckedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    computedIndeterminateKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    getPublicCheckedKeys: (rawCheckedKeys: import("../tree/interface").TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => import("../tree/interface").TreeNodeKey[];
                    getNodes: (keys: import("../tree/interface").TreeNodeKey[]) => (import("..").TreeNodeData | undefined)[];
                    internalCheckNodes: (keys: import("../tree/interface").TreeNodeKey[], checked: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                    internalSetCheckedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                    internalSelectNodes: (keys: import("../tree/interface").TreeNodeKey[], selected: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                    internalSetSelectedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                    internalExpandNodes: (keys: import("../tree/interface").TreeNodeKey[], expanded: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                    internalSetExpandedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                }, {}, {}, {
                    toggleCheck(key: import("../tree/interface").TreeNodeKey, e: Event): void;
                    scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
                    getSelectedNodes(): (import("..").TreeNodeData | undefined)[];
                    getCheckedNodes(options?: {
                        checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                        includeHalfChecked?: boolean | undefined;
                    }): (import("..").TreeNodeData | undefined)[];
                    getHalfCheckedNodes(): (import("..").TreeNodeData | undefined)[];
                    getExpandedNodes(): (import("..").TreeNodeData | undefined)[];
                    checkAll(checked?: boolean): void;
                    checkNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
                    selectAll(selected?: boolean): void;
                    selectNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], selected?: boolean): void;
                    expandAll(expanded?: boolean): void;
                    expandNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], expanded?: boolean): void;
                }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    select: (selectedKeys: (string | number)[], data: {
                        selected?: boolean | undefined;
                        selectedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => true;
                    'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
                    check: (checkedKeys: (string | number)[], data: {
                        checked?: boolean | undefined;
                        checkedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        halfCheckedKeys: (string | number)[];
                        halfCheckedNodes: import("..").TreeNodeData[];
                        e?: Event | undefined;
                    }) => true;
                    'update:checkedKeys': (checkedKeys: (string | number)[]) => true;
                    'update:halfCheckedKeys': (halfCheckedKeys: (string | number)[]) => true;
                    expand: (expandKeys: (string | number)[], data: {
                        expanded?: boolean | undefined;
                        expandedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => true;
                    'update:expandedKeys': (expandKeys: (string | number)[]) => true;
                    dragStart: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                    dragEnd: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                    dragOver: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                    dragLeave: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                    drop: (data: {
                        e: DragEvent;
                        dragNode: import("..").TreeNodeData;
                        dropNode: import("..").TreeNodeData;
                        dropPosition: number;
                    }) => true;
                }, import("vue").PublicProps, {
                    size: "mini" | "small" | "medium" | "large";
                    data: import("..").TreeNodeData[];
                    multiple: boolean;
                    animation: boolean;
                    draggable: boolean;
                    checkStrictly: boolean;
                    checkable: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    showLine: boolean;
                    selectable: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    blockNode: boolean;
                    defaultExpandAll: boolean;
                    checkedStrategy: "all" | "child" | "parent";
                    searchValue: string;
                    defaultExpandSelected: boolean;
                    defaultExpandChecked: boolean;
                    autoExpandParent: boolean;
                    onlyCheckLeaf: boolean;
                    disableSelectActionOnly: boolean;
                }, true, {}, {}, {
                    VirtualList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        data: {
                            type: import("vue").PropType<Record<string, any>[]>;
                            default: () => never[];
                        };
                        threshold: {
                            type: NumberConstructor;
                            default: number;
                        };
                        itemKey: {
                            type: StringConstructor;
                            default: string;
                        };
                        fixedSize: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        estimatedSize: {
                            type: NumberConstructor;
                            default: number;
                        };
                        buffer: {
                            type: NumberConstructor;
                            default: number;
                        };
                        component: {
                            type: (ObjectConstructor | StringConstructor)[];
                            default: string;
                        };
                        listAttrs: {
                            type: ObjectConstructor;
                        };
                        contentAttrs: {
                            type: ObjectConstructor;
                        };
                        paddingPosition: {
                            type: StringConstructor;
                            default: string;
                        };
                    }>, {
                        prefixCls: string;
                        containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                        contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                        frontPadding: import("vue").ComputedRef<number>;
                        currentList: import("vue").ComputedRef<Record<string, any>[]>;
                        behindPadding: import("vue").ComputedRef<number>;
                        onScroll: (ev: Event) => void;
                        setItemSize: (key: string | number, size: number) => void;
                        hasItemSize: (key: string | number) => boolean;
                        start: import("vue").Ref<number, number>;
                        scrollTo: (options: import("../_components/virtual-list-v2/interface").ScrollOptions) => void;
                        style: import("vue").ComputedRef<{
                            height: string;
                            overflow: string;
                        }>;
                        mergedComponent: import("vue").ComputedRef<{
                            container: string;
                            list: string;
                            content: string;
                        }>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                        scroll: (ev: Event) => true;
                        reachBottom: (ev: Event) => true;
                    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        data: {
                            type: import("vue").PropType<Record<string, any>[]>;
                            default: () => never[];
                        };
                        threshold: {
                            type: NumberConstructor;
                            default: number;
                        };
                        itemKey: {
                            type: StringConstructor;
                            default: string;
                        };
                        fixedSize: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        estimatedSize: {
                            type: NumberConstructor;
                            default: number;
                        };
                        buffer: {
                            type: NumberConstructor;
                            default: number;
                        };
                        component: {
                            type: (ObjectConstructor | StringConstructor)[];
                            default: string;
                        };
                        listAttrs: {
                            type: ObjectConstructor;
                        };
                        contentAttrs: {
                            type: ObjectConstructor;
                        };
                        paddingPosition: {
                            type: StringConstructor;
                            default: string;
                        };
                    }>> & Readonly<{
                        onScroll?: ((ev: Event) => any) | undefined;
                        onReachBottom?: ((ev: Event) => any) | undefined;
                    }>, {
                        data: Record<string, any>[];
                        height: string | number;
                        threshold: number;
                        itemKey: string;
                        fixedSize: boolean;
                        estimatedSize: number;
                        buffer: number;
                        component: string | Record<string, any>;
                        paddingPosition: string;
                    }, {}, {
                        VirtualListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            hasItemSize: {
                                type: FunctionConstructor;
                                required: true;
                            };
                            setItemSize: {
                                type: FunctionConstructor;
                                required: true;
                            };
                        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                            hasItemSize: {
                                type: FunctionConstructor;
                                required: true;
                            };
                            setItemSize: {
                                type: FunctionConstructor;
                                required: true;
                            };
                        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    TreeNode: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
                        [x: string]: 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<{
                    size: {
                        type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                        default: string;
                    };
                    blockNode: {
                        type: BooleanConstructor;
                    };
                    defaultExpandAll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                    };
                    checkable: {
                        type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean)>;
                        default: boolean;
                    };
                    selectable: {
                        type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean)>;
                        default: boolean;
                    };
                    checkStrictly: {
                        type: BooleanConstructor;
                    };
                    checkedStrategy: {
                        type: import("vue").PropType<"all" | "child" | "parent">;
                        default: string;
                    };
                    defaultSelectedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    selectedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    defaultCheckedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    checkedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    defaultExpandedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    expandedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    data: {
                        type: import("vue").PropType<import("..").TreeNodeData[]>;
                        default: () => never[];
                    };
                    fieldNames: {
                        type: import("vue").PropType<import("..").TreeFieldNames>;
                    };
                    showLine: {
                        type: BooleanConstructor;
                    };
                    loadMore: {
                        type: import("vue").PropType<(node: import("..").TreeNodeData) => Promise<void>>;
                    };
                    draggable: {
                        type: BooleanConstructor;
                    };
                    allowDrop: {
                        type: import("vue").PropType<(options: {
                            dropNode: import("..").TreeNodeData;
                            dropPosition: 0 | 1 | -1;
                        }) => boolean>;
                    };
                    filterTreeNode: {
                        type: import("vue").PropType<import("../tree/interface").FilterTreeNode>;
                    };
                    searchValue: {
                        type: StringConstructor;
                        default: string;
                    };
                    virtualListProps: {
                        type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                    };
                    defaultExpandSelected: {
                        type: BooleanConstructor;
                    };
                    defaultExpandChecked: {
                        type: BooleanConstructor;
                    };
                    autoExpandParent: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    halfCheckedKeys: {
                        type: import("vue").PropType<(string | number)[]>;
                    };
                    onlyCheckLeaf: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    animation: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    actionOnNodeClick: {
                        type: import("vue").PropType<"expand">;
                    };
                    disableSelectActionOnly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onSelect?: ((selectedKeys: (string | number)[], data: {
                        selected?: boolean | undefined;
                        selectedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    onDrop?: ((data: {
                        e: DragEvent;
                        dragNode: import("..").TreeNodeData;
                        dropNode: import("..").TreeNodeData;
                        dropPosition: number;
                    }) => any) | undefined;
                    "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
                    "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
                    onExpand?: ((expandKeys: (string | number)[], data: {
                        expanded?: boolean | undefined;
                        expandedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    onCheck?: ((checkedKeys: (string | number)[], data: {
                        checked?: boolean | undefined;
                        checkedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        halfCheckedKeys: (string | number)[];
                        halfCheckedNodes: import("..").TreeNodeData[];
                        e?: Event | undefined;
                    }) => any) | undefined;
                    onDragStart?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    onDragOver?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    onDragLeave?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    onDragEnd?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
                    "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                }>, {
                    classNames: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                    })[]>;
                    visibleTreeNodeList: import("vue").ComputedRef<import("../tree/interface").Node[]>;
                    treeContext: {
                        treeProps: {
                            readonly size: "mini" | "small" | "medium" | "large";
                            readonly data: {
                                key?: string | number | undefined;
                                title?: string | undefined;
                                selectable?: boolean | undefined;
                                disabled?: boolean | undefined;
                                disableCheckbox?: boolean | undefined;
                                checkable?: boolean | undefined;
                                draggable?: boolean | undefined;
                                isLeaf?: boolean | undefined;
                                icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                children?: any[] | undefined;
                            }[];
                            readonly multiple: boolean;
                            readonly animation: boolean;
                            readonly draggable: boolean;
                            readonly checkStrictly: boolean;
                            readonly checkable: boolean | ((node: import("..").TreeNodeData, info: {
                                level: number;
                                isLeaf: boolean;
                            }) => boolean);
                            readonly showLine: boolean;
                            readonly selectable: boolean | ((node: import("..").TreeNodeData, info: {
                                level: number;
                                isLeaf: boolean;
                            }) => boolean);
                            readonly blockNode: boolean;
                            readonly defaultExpandAll: boolean;
                            readonly checkedStrategy: "all" | "child" | "parent";
                            readonly searchValue: string;
                            readonly defaultExpandSelected: boolean;
                            readonly defaultExpandChecked: boolean;
                            readonly autoExpandParent: boolean;
                            readonly onlyCheckLeaf: boolean;
                            readonly disableSelectActionOnly: boolean;
                            readonly fieldNames: {
                                key?: string | undefined;
                                title?: string | undefined;
                                disabled?: string | undefined;
                                children?: string | undefined;
                                isLeaf?: string | undefined;
                                disableCheckbox?: string | undefined;
                                checkable?: string | undefined;
                                icon?: string | undefined;
                            } | undefined;
                            readonly virtualListProps: {
                                height?: string | number | undefined;
                                threshold?: number | undefined;
                                isStaticItemHeight?: boolean | undefined;
                                fixedSize?: boolean | undefined;
                                estimatedSize?: number | undefined;
                                buffer?: number | undefined;
                                data?: unknown[] | undefined;
                                itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
                                component?: keyof HTMLElementTagNameMap | undefined;
                            } | undefined;
                            readonly loadMore: ((node: import("..").TreeNodeData) => Promise<void>) | undefined;
                            readonly selectedKeys: (string | number)[] | undefined;
                            readonly defaultSelectedKeys: (string | number)[] | undefined;
                            readonly expandedKeys: (string | number)[] | undefined;
                            readonly defaultExpandedKeys: (string | number)[] | undefined;
                            readonly checkedKeys: (string | number)[] | undefined;
                            readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                            readonly allowDrop: ((options: {
                                dropNode: import("..").TreeNodeData;
                                dropPosition: 0 | 1 | -1;
                            }) => boolean) | undefined;
                            readonly defaultCheckedKeys: (string | number)[] | undefined;
                            readonly halfCheckedKeys: (string | number)[] | undefined;
                            readonly actionOnNodeClick: "expand" | undefined;
                            readonly onSelect: ((selectedKeys: (string | number)[], data: {
                                selected?: boolean | undefined;
                                selectedNodes: import("..").TreeNodeData[];
                                node?: import("..").TreeNodeData | undefined;
                                e?: Event | undefined;
                            }) => any) | undefined;
                            readonly onDrop: ((data: {
                                e: DragEvent;
                                dragNode: import("..").TreeNodeData;
                                dropNode: import("..").TreeNodeData;
                                dropPosition: number;
                            }) => any) | undefined;
                            readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
                            readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
                            readonly onExpand: ((expandKeys: (string | number)[], data: {
                                expanded?: boolean | undefined;
                                expandedNodes: import("..").TreeNodeData[];
                                node?: import("..").TreeNodeData | undefined;
                                e?: Event | undefined;
                            }) => any) | undefined;
                            readonly onCheck: ((checkedKeys: (string | number)[], data: {
                                checked?: boolean | undefined;
                                checkedNodes: import("..").TreeNodeData[];
                                node?: import("..").TreeNodeData | undefined;
                                halfCheckedKeys: (string | number)[];
                                halfCheckedNodes: import("..").TreeNodeData[];
                                e?: Event | undefined;
                            }) => any) | undefined;
                            readonly onDragStart: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly onDragOver: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly onDragLeave: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly onDragEnd: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                            readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
                            readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                        };
                        switcherIcon: import("vue").Slot<any> | undefined;
                        loadingIcon: import("vue").Slot<any> | undefined;
                        dragIcon: import("vue").Slot<any> | undefined;
                        nodeIcon: import("vue").Slot<any> | undefined;
                        nodeTitle: import("vue").Slot<any> | undefined;
                        nodeExtra: import("vue").Slot<any> | undefined;
                        treeData: {
                            key: import("../tree/interface").TreeNodeKey;
                            treeNodeProps: {
                                selectable: boolean;
                                disabled: boolean;
                                disableCheckbox: boolean;
                                checkable: boolean;
                                draggable: boolean;
                                isLeaf: boolean;
                                isTail: boolean;
                                blockNode: boolean;
                                showLine: boolean;
                                level: number;
                                lineless: boolean[];
                                title?: string | undefined;
                                key?: string | number | undefined;
                                icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                            };
                            treeNodeData: {
                                key?: string | number | undefined;
                                title?: string | undefined;
                                selectable?: boolean | undefined;
                                disabled?: boolean | undefined;
                                disableCheckbox?: boolean | undefined;
                                checkable?: boolean | undefined;
                                draggable?: boolean | undefined;
                                isLeaf?: boolean | undefined;
                                icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                    [key: string]: any;
                                }>) | undefined;
                                children?: any[] | undefined;
                            };
                            parent?: any | undefined;
                            parentKey?: import("../tree/interface").TreeNodeKey | undefined;
                            pathParentKeys: import("../tree/interface").TreeNodeKey[];
                            children?: any[] | undefined;
                            selectable: boolean;
                            disabled: boolean;
                            disableCheckbox: boolean;
                            checkable: boolean;
                            draggable: boolean;
                            isLeaf: boolean;
                            isTail: boolean;
                            blockNode: boolean;
                            showLine: boolean;
                            level: number;
                            lineless: boolean[];
                            title?: string | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                        }[];
                        flattenTreeData: import("../tree/interface").Node[];
                        key2TreeNode: import("../tree/interface").Key2TreeNode;
                        checkedKeys: import("../tree/interface").TreeNodeKey[];
                        indeterminateKeys: import("../tree/interface").TreeNodeKey[];
                        selectedKeys: import("../tree/interface").TreeNodeKey[];
                        expandedKeys: import("../tree/interface").TreeNodeKey[];
                        loadingKeys: import("../tree/interface").TreeNodeKey[];
                        currentExpandKeys: import("../tree/interface").TreeNodeKey[];
                        onLoadMore: ((key: import("../tree/interface").TreeNodeKey) => Promise<void>) | undefined;
                        filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                        onCheck: (checked: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                        onSelect: (key: import("../tree/interface").TreeNodeKey, e: Event) => void;
                        onExpand: (expanded: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                        onExpandEnd: (key: import("../tree/interface").TreeNodeKey) => void;
                        allowDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                        onDragStart: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDragEnd: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDragOver: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDragLeave: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                        onDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: number, e: DragEvent) => void;
                    };
                    virtualListRef: import("vue").Ref<any, any>;
                    computedSelectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    computedExpandedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    computedCheckedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    computedIndeterminateKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                    getPublicCheckedKeys: (rawCheckedKeys: import("../tree/interface").TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => import("../tree/interface").TreeNodeKey[];
                    getNodes: (keys: import("../tree/interface").TreeNodeKey[]) => (import("..").TreeNodeData | undefined)[];
                    internalCheckNodes: (keys: import("../tree/interface").TreeNodeKey[], checked: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                    internalSetCheckedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                    internalSelectNodes: (keys: import("../tree/interface").TreeNodeKey[], selected: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                    internalSetSelectedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                    internalExpandNodes: (keys: import("../tree/interface").TreeNodeKey[], expanded: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                    internalSetExpandedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                }, {}, {}, {
                    toggleCheck(key: import("../tree/interface").TreeNodeKey, e: Event): void;
                    scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
                    getSelectedNodes(): (import("..").TreeNodeData | undefined)[];
                    getCheckedNodes(options?: {
                        checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                        includeHalfChecked?: boolean | undefined;
                    }): (import("..").TreeNodeData | undefined)[];
                    getHalfCheckedNodes(): (import("..").TreeNodeData | undefined)[];
                    getExpandedNodes(): (import("..").TreeNodeData | undefined)[];
                    checkAll(checked?: boolean): void;
                    checkNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
                    selectAll(selected?: boolean): void;
                    selectNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], selected?: boolean): void;
                    expandAll(expanded?: boolean): void;
                    expandNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], expanded?: boolean): void;
                }, {
                    size: "mini" | "small" | "medium" | "large";
                    data: import("..").TreeNodeData[];
                    multiple: boolean;
                    animation: boolean;
                    draggable: boolean;
                    checkStrictly: boolean;
                    checkable: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    showLine: boolean;
                    selectable: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    blockNode: boolean;
                    defaultExpandAll: boolean;
                    checkedStrategy: "all" | "child" | "parent";
                    searchValue: string;
                    defaultExpandSelected: boolean;
                    defaultExpandChecked: boolean;
                    autoExpandParent: boolean;
                    onlyCheckLeaf: boolean;
                    disableSelectActionOnly: boolean;
                }>;
                __isFragment?: undefined;
                __isTeleport?: undefined;
                __isSuspense?: undefined;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                    default: string;
                };
                blockNode: {
                    type: BooleanConstructor;
                };
                defaultExpandAll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                };
                checkable: {
                    type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean)>;
                    default: boolean;
                };
                selectable: {
                    type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean)>;
                    default: boolean;
                };
                checkStrictly: {
                    type: BooleanConstructor;
                };
                checkedStrategy: {
                    type: import("vue").PropType<"all" | "child" | "parent">;
                    default: string;
                };
                defaultSelectedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                selectedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                defaultCheckedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                checkedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                defaultExpandedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                expandedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                data: {
                    type: import("vue").PropType<import("..").TreeNodeData[]>;
                    default: () => never[];
                };
                fieldNames: {
                    type: import("vue").PropType<import("..").TreeFieldNames>;
                };
                showLine: {
                    type: BooleanConstructor;
                };
                loadMore: {
                    type: import("vue").PropType<(node: import("..").TreeNodeData) => Promise<void>>;
                };
                draggable: {
                    type: BooleanConstructor;
                };
                allowDrop: {
                    type: import("vue").PropType<(options: {
                        dropNode: import("..").TreeNodeData;
                        dropPosition: 0 | 1 | -1;
                    }) => boolean>;
                };
                filterTreeNode: {
                    type: import("vue").PropType<import("../tree/interface").FilterTreeNode>;
                };
                searchValue: {
                    type: StringConstructor;
                    default: string;
                };
                virtualListProps: {
                    type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                };
                defaultExpandSelected: {
                    type: BooleanConstructor;
                };
                defaultExpandChecked: {
                    type: BooleanConstructor;
                };
                autoExpandParent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                halfCheckedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                onlyCheckLeaf: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                animation: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                actionOnNodeClick: {
                    type: import("vue").PropType<"expand">;
                };
                disableSelectActionOnly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onSelect?: ((selectedKeys: (string | number)[], data: {
                    selected?: boolean | undefined;
                    selectedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                onDrop?: ((data: {
                    e: DragEvent;
                    dragNode: import("..").TreeNodeData;
                    dropNode: import("..").TreeNodeData;
                    dropPosition: number;
                }) => any) | undefined;
                "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
                "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
                onExpand?: ((expandKeys: (string | number)[], data: {
                    expanded?: boolean | undefined;
                    expandedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                onCheck?: ((checkedKeys: (string | number)[], data: {
                    checked?: boolean | undefined;
                    checkedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    halfCheckedKeys: (string | number)[];
                    halfCheckedNodes: import("..").TreeNodeData[];
                    e?: Event | undefined;
                }) => any) | undefined;
                onDragStart?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragOver?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragLeave?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragEnd?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
                "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
            }>, {
                classNames: import("vue").ComputedRef<(string | {
                    [x: string]: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                })[]>;
                visibleTreeNodeList: import("vue").ComputedRef<import("../tree/interface").Node[]>;
                treeContext: {
                    treeProps: {
                        readonly size: "mini" | "small" | "medium" | "large";
                        readonly data: {
                            key?: string | number | undefined;
                            title?: string | undefined;
                            selectable?: boolean | undefined;
                            disabled?: boolean | undefined;
                            disableCheckbox?: boolean | undefined;
                            checkable?: boolean | undefined;
                            draggable?: boolean | undefined;
                            isLeaf?: boolean | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            children?: any[] | undefined;
                        }[];
                        readonly multiple: boolean;
                        readonly animation: boolean;
                        readonly draggable: boolean;
                        readonly checkStrictly: boolean;
                        readonly checkable: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                        readonly showLine: boolean;
                        readonly selectable: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                        readonly blockNode: boolean;
                        readonly defaultExpandAll: boolean;
                        readonly checkedStrategy: "all" | "child" | "parent";
                        readonly searchValue: string;
                        readonly defaultExpandSelected: boolean;
                        readonly defaultExpandChecked: boolean;
                        readonly autoExpandParent: boolean;
                        readonly onlyCheckLeaf: boolean;
                        readonly disableSelectActionOnly: boolean;
                        readonly fieldNames: {
                            key?: string | undefined;
                            title?: string | undefined;
                            disabled?: string | undefined;
                            children?: string | undefined;
                            isLeaf?: string | undefined;
                            disableCheckbox?: string | undefined;
                            checkable?: string | undefined;
                            icon?: string | undefined;
                        } | undefined;
                        readonly virtualListProps: {
                            height?: string | number | undefined;
                            threshold?: number | undefined;
                            isStaticItemHeight?: boolean | undefined;
                            fixedSize?: boolean | undefined;
                            estimatedSize?: number | undefined;
                            buffer?: number | undefined;
                            data?: unknown[] | undefined;
                            itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
                            component?: keyof HTMLElementTagNameMap | undefined;
                        } | undefined;
                        readonly loadMore: ((node: import("..").TreeNodeData) => Promise<void>) | undefined;
                        readonly selectedKeys: (string | number)[] | undefined;
                        readonly defaultSelectedKeys: (string | number)[] | undefined;
                        readonly expandedKeys: (string | number)[] | undefined;
                        readonly defaultExpandedKeys: (string | number)[] | undefined;
                        readonly checkedKeys: (string | number)[] | undefined;
                        readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                        readonly allowDrop: ((options: {
                            dropNode: import("..").TreeNodeData;
                            dropPosition: 0 | 1 | -1;
                        }) => boolean) | undefined;
                        readonly defaultCheckedKeys: (string | number)[] | undefined;
                        readonly halfCheckedKeys: (string | number)[] | undefined;
                        readonly actionOnNodeClick: "expand" | undefined;
                        readonly onSelect: ((selectedKeys: (string | number)[], data: {
                            selected?: boolean | undefined;
                            selectedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onDrop: ((data: {
                            e: DragEvent;
                            dragNode: import("..").TreeNodeData;
                            dropNode: import("..").TreeNodeData;
                            dropPosition: number;
                        }) => any) | undefined;
                        readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
                        readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
                        readonly onExpand: ((expandKeys: (string | number)[], data: {
                            expanded?: boolean | undefined;
                            expandedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onCheck: ((checkedKeys: (string | number)[], data: {
                            checked?: boolean | undefined;
                            checkedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            halfCheckedKeys: (string | number)[];
                            halfCheckedNodes: import("..").TreeNodeData[];
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onDragStart: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragOver: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragLeave: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragEnd: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
                        readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                    };
                    switcherIcon: import("vue").Slot<any> | undefined;
                    loadingIcon: import("vue").Slot<any> | undefined;
                    dragIcon: import("vue").Slot<any> | undefined;
                    nodeIcon: import("vue").Slot<any> | undefined;
                    nodeTitle: import("vue").Slot<any> | undefined;
                    nodeExtra: import("vue").Slot<any> | undefined;
                    treeData: {
                        key: import("../tree/interface").TreeNodeKey;
                        treeNodeProps: {
                            selectable: boolean;
                            disabled: boolean;
                            disableCheckbox: boolean;
                            checkable: boolean;
                            draggable: boolean;
                            isLeaf: boolean;
                            isTail: boolean;
                            blockNode: boolean;
                            showLine: boolean;
                            level: number;
                            lineless: boolean[];
                            title?: string | undefined;
                            key?: string | number | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                        };
                        treeNodeData: {
                            key?: string | number | undefined;
                            title?: string | undefined;
                            selectable?: boolean | undefined;
                            disabled?: boolean | undefined;
                            disableCheckbox?: boolean | undefined;
                            checkable?: boolean | undefined;
                            draggable?: boolean | undefined;
                            isLeaf?: boolean | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            children?: any[] | undefined;
                        };
                        parent?: any | undefined;
                        parentKey?: import("../tree/interface").TreeNodeKey | undefined;
                        pathParentKeys: import("../tree/interface").TreeNodeKey[];
                        children?: any[] | undefined;
                        selectable: boolean;
                        disabled: boolean;
                        disableCheckbox: boolean;
                        checkable: boolean;
                        draggable: boolean;
                        isLeaf: boolean;
                        isTail: boolean;
                        blockNode: boolean;
                        showLine: boolean;
                        level: number;
                        lineless: boolean[];
                        title?: string | undefined;
                        icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                    }[];
                    flattenTreeData: import("../tree/interface").Node[];
                    key2TreeNode: import("../tree/interface").Key2TreeNode;
                    checkedKeys: import("../tree/interface").TreeNodeKey[];
                    indeterminateKeys: import("../tree/interface").TreeNodeKey[];
                    selectedKeys: import("../tree/interface").TreeNodeKey[];
                    expandedKeys: import("../tree/interface").TreeNodeKey[];
                    loadingKeys: import("../tree/interface").TreeNodeKey[];
                    currentExpandKeys: import("../tree/interface").TreeNodeKey[];
                    onLoadMore: ((key: import("../tree/interface").TreeNodeKey) => Promise<void>) | undefined;
                    filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                    onCheck: (checked: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                    onSelect: (key: import("../tree/interface").TreeNodeKey, e: Event) => void;
                    onExpand: (expanded: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                    onExpandEnd: (key: import("../tree/interface").TreeNodeKey) => void;
                    allowDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                    onDragStart: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragEnd: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragOver: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragLeave: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: number, e: DragEvent) => void;
                };
                virtualListRef: import("vue").Ref<any, any>;
                computedSelectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedExpandedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedCheckedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedIndeterminateKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                getPublicCheckedKeys: (rawCheckedKeys: import("../tree/interface").TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => import("../tree/interface").TreeNodeKey[];
                getNodes: (keys: import("../tree/interface").TreeNodeKey[]) => (import("..").TreeNodeData | undefined)[];
                internalCheckNodes: (keys: import("../tree/interface").TreeNodeKey[], checked: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetCheckedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                internalSelectNodes: (keys: import("../tree/interface").TreeNodeKey[], selected: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetSelectedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                internalExpandNodes: (keys: import("../tree/interface").TreeNodeKey[], expanded: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetExpandedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
            }, {}, {}, {
                toggleCheck(key: import("../tree/interface").TreeNodeKey, e: Event): void;
                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
                getSelectedNodes(): (import("..").TreeNodeData | undefined)[];
                getCheckedNodes(options?: {
                    checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                    includeHalfChecked?: boolean | undefined;
                }): (import("..").TreeNodeData | undefined)[];
                getHalfCheckedNodes(): (import("..").TreeNodeData | undefined)[];
                getExpandedNodes(): (import("..").TreeNodeData | undefined)[];
                checkAll(checked?: boolean): void;
                checkNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
                selectAll(selected?: boolean): void;
                selectNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], selected?: boolean): void;
                expandAll(expanded?: boolean): void;
                expandNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], expanded?: boolean): void;
            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                select: (selectedKeys: (string | number)[], data: {
                    selected?: boolean | undefined;
                    selectedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => true;
                'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
                check: (checkedKeys: (string | number)[], data: {
                    checked?: boolean | undefined;
                    checkedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    halfCheckedKeys: (string | number)[];
                    halfCheckedNodes: import("..").TreeNodeData[];
                    e?: Event | undefined;
                }) => true;
                'update:checkedKeys': (checkedKeys: (string | number)[]) => true;
                'update:halfCheckedKeys': (halfCheckedKeys: (string | number)[]) => true;
                expand: (expandKeys: (string | number)[], data: {
                    expanded?: boolean | undefined;
                    expandedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => true;
                'update:expandedKeys': (expandKeys: (string | number)[]) => true;
                dragStart: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                dragEnd: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                dragOver: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                dragLeave: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                drop: (data: {
                    e: DragEvent;
                    dragNode: import("..").TreeNodeData;
                    dropNode: import("..").TreeNodeData;
                    dropPosition: number;
                }) => true;
            }, string, {
                size: "mini" | "small" | "medium" | "large";
                data: import("..").TreeNodeData[];
                multiple: boolean;
                animation: boolean;
                draggable: boolean;
                checkStrictly: boolean;
                checkable: boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
                showLine: boolean;
                selectable: boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
                blockNode: boolean;
                defaultExpandAll: boolean;
                checkedStrategy: "all" | "child" | "parent";
                searchValue: string;
                defaultExpandSelected: boolean;
                defaultExpandChecked: boolean;
                autoExpandParent: boolean;
                onlyCheckLeaf: boolean;
                disableSelectActionOnly: boolean;
            }, {}, string, {}, {
                VirtualList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    data: {
                        type: import("vue").PropType<Record<string, any>[]>;
                        default: () => never[];
                    };
                    threshold: {
                        type: NumberConstructor;
                        default: number;
                    };
                    itemKey: {
                        type: StringConstructor;
                        default: string;
                    };
                    fixedSize: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    estimatedSize: {
                        type: NumberConstructor;
                        default: number;
                    };
                    buffer: {
                        type: NumberConstructor;
                        default: number;
                    };
                    component: {
                        type: (ObjectConstructor | StringConstructor)[];
                        default: string;
                    };
                    listAttrs: {
                        type: ObjectConstructor;
                    };
                    contentAttrs: {
                        type: ObjectConstructor;
                    };
                    paddingPosition: {
                        type: StringConstructor;
                        default: string;
                    };
                }>, {
                    prefixCls: string;
                    containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    frontPadding: import("vue").ComputedRef<number>;
                    currentList: import("vue").ComputedRef<Record<string, any>[]>;
                    behindPadding: import("vue").ComputedRef<number>;
                    onScroll: (ev: Event) => void;
                    setItemSize: (key: string | number, size: number) => void;
                    hasItemSize: (key: string | number) => boolean;
                    start: import("vue").Ref<number, number>;
                    scrollTo: (options: import("../_components/virtual-list-v2/interface").ScrollOptions) => void;
                    style: import("vue").ComputedRef<{
                        height: string;
                        overflow: string;
                    }>;
                    mergedComponent: import("vue").ComputedRef<{
                        container: string;
                        list: string;
                        content: string;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    scroll: (ev: Event) => true;
                    reachBottom: (ev: Event) => true;
                }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    data: {
                        type: import("vue").PropType<Record<string, any>[]>;
                        default: () => never[];
                    };
                    threshold: {
                        type: NumberConstructor;
                        default: number;
                    };
                    itemKey: {
                        type: StringConstructor;
                        default: string;
                    };
                    fixedSize: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    estimatedSize: {
                        type: NumberConstructor;
                        default: number;
                    };
                    buffer: {
                        type: NumberConstructor;
                        default: number;
                    };
                    component: {
                        type: (ObjectConstructor | StringConstructor)[];
                        default: string;
                    };
                    listAttrs: {
                        type: ObjectConstructor;
                    };
                    contentAttrs: {
                        type: ObjectConstructor;
                    };
                    paddingPosition: {
                        type: StringConstructor;
                        default: string;
                    };
                }>> & Readonly<{
                    onScroll?: ((ev: Event) => any) | undefined;
                    onReachBottom?: ((ev: Event) => any) | undefined;
                }>, {
                    data: Record<string, any>[];
                    height: string | number;
                    threshold: number;
                    itemKey: string;
                    fixedSize: boolean;
                    estimatedSize: number;
                    buffer: number;
                    component: string | Record<string, any>;
                    paddingPosition: string;
                }, {}, {
                    VirtualListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        hasItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                        setItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        hasItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                        setItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                TreeNode: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
                    [x: string]: any;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: (app: App<any>, options?: ArcoOptions | undefined) => void;
            };
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        Empty: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                description: StringConstructor;
                imgSrc: StringConstructor;
                inConfigProvider: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                inConfigProvider: boolean;
            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                description: StringConstructor;
                imgSrc: StringConstructor;
                inConfigProvider: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                inConfigProvider: boolean;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            description: StringConstructor;
            imgSrc: StringConstructor;
            inConfigProvider: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            inConfigProvider: boolean;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
        Spin: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                size: {
                    type: NumberConstructor;
                };
                loading: BooleanConstructor;
                dot: BooleanConstructor;
                tip: StringConstructor;
                hideIcon: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                loading: boolean;
                dot: boolean;
                hideIcon: boolean;
            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                size: {
                    type: NumberConstructor;
                };
                loading: BooleanConstructor;
                dot: BooleanConstructor;
                tip: StringConstructor;
                hideIcon: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                loading: boolean;
                dot: boolean;
                hideIcon: boolean;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            size: {
                type: NumberConstructor;
            };
            loading: BooleanConstructor;
            dot: BooleanConstructor;
            tip: StringConstructor;
            hideIcon: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            loading: boolean;
            dot: boolean;
            hideIcon: boolean;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        disabled: {
            type: BooleanConstructor;
        };
        loading: {
            type: BooleanConstructor;
        };
        error: {
            type: BooleanConstructor;
        };
        size: {
            type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
        };
        border: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowSearch: {
            type: import("vue").PropType<boolean | {
                retainInputValue?: boolean | undefined;
            }>;
            default: (props: import("../_utils/types").Data) => boolean;
        };
        allowClear: {
            type: BooleanConstructor;
        };
        placeholder: {
            type: StringConstructor;
        };
        maxTagCount: {
            type: NumberConstructor;
        };
        multiple: {
            type: BooleanConstructor;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[]>;
        };
        modelValue: {
            type: import("vue").PropType<string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[]>;
        };
        fieldNames: {
            type: import("vue").PropType<import("..").TreeFieldNames>;
        };
        data: {
            type: import("vue").PropType<import("..").TreeNodeData[]>;
            default: () => never[];
        };
        labelInValue: {
            type: BooleanConstructor;
        };
        treeCheckable: {
            type: BooleanConstructor;
        };
        treeCheckStrictly: {
            type: BooleanConstructor;
        };
        treeCheckedStrategy: {
            type: import("vue").PropType<"all" | "child" | "parent">;
            default: string;
        };
        treeProps: {
            type: import("vue").PropType<Partial<import("../tree/interface").TreeProps>>;
        };
        triggerProps: {
            type: import("vue").PropType<Partial<import("..").TriggerProps>>;
        };
        popupVisible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultPopupVisible: {
            type: BooleanConstructor;
        };
        dropdownStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        dropdownClassName: {
            type: import("vue").PropType<string | string[]>;
        };
        filterTreeNode: {
            type: import("vue").PropType<(searchKey: string, nodeData: import("..").TreeNodeData) => boolean>;
        };
        loadMore: {
            type: import("vue").PropType<(nodeData: import("..").TreeNodeData) => Promise<void>>;
        };
        disableFilter: {
            type: BooleanConstructor;
        };
        popupContainer: {
            type: import("vue").PropType<string | HTMLElement>;
        };
        fallbackOption: {
            type: import("vue").PropType<boolean | ((key: string | number) => boolean | import("..").TreeNodeData)>;
            default: boolean;
        };
        selectable: {
            type: import("vue").PropType<boolean | "leaf" | ((node: import("..").TreeNodeData, info: {
                isLeaf: boolean;
                level: number;
            }) => boolean)>;
            default: boolean;
        };
        scrollbar: {
            type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
            default: boolean;
        };
        showHeaderOnEmpty: {
            type: import("vue").PropType<boolean>;
            default: boolean;
        };
        showFooterOnEmpty: {
            type: import("vue").PropType<boolean>;
            default: boolean;
        };
        inputValue: {
            type: StringConstructor;
        };
        defaultInputValue: {
            type: StringConstructor;
            default: string;
        };
    }>> & Readonly<{
        onClear?: (() => any) | undefined;
        onChange?: ((value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => any) | undefined;
        "onUpdate:inputValue"?: ((inputValue: string) => any) | undefined;
        onInputValueChange?: ((inputValue: string) => any) | undefined;
        "onUpdate:modelValue"?: ((value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => any) | undefined;
        "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
        onSearch?: ((searchKey: string) => any) | undefined;
        "onPopup-visible-change"?: ((visible: boolean) => any) | undefined;
    }>, {
        refSelectView: import("vue").Ref<any, any>;
        prefixCls: string;
        TreeSelectEmpty: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | undefined;
        selectedValue: import("vue").ComputedRef<import("./interface").LabelValue[]>;
        selectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
        mergedDisabled: import("vue").ComputedRef<boolean>;
        searchValue: import("vue").ComputedRef<string>;
        panelVisible: import("vue").ComputedRef<boolean>;
        isEmpty: import("vue").ComputedRef<boolean | undefined>;
        computedFilterTreeNode: import("vue").ComputedRef<((node: import("..").TreeNodeData) => boolean) | undefined>;
        isMultiple: import("vue").ComputedRef<boolean>;
        selectViewValue: import("vue").ComputedRef<import("../_components/select-view/interface").SelectViewValue[]>;
        computedDropdownStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
        onSearchValueChange: (inputValue: string) => void;
        onSelectChange(newVal: string[]): void;
        onVisibleChange: (visible: boolean) => void;
        onInnerClear(): void;
        pickSubCompSlots: typeof import("../_utils/pick-sub-comp-slots").default;
        isSelectable: (node: import("..").TreeNodeData, info: {
            level: number;
            isLeaf: boolean;
        }) => boolean;
        isCheckable: import("vue").ComputedRef<false | ((node: import("..").TreeNodeData, info: {
            level: number;
            isLeaf: boolean;
        }) => boolean)>;
        onBlur: () => void;
        onItemRemove(id: string): void;
    }, {}, {}, {}, {
        disabled: boolean;
        error: boolean;
        allowClear: boolean;
        data: import("..").TreeNodeData[];
        loading: boolean;
        multiple: boolean;
        allowSearch: boolean | {
            retainInputValue?: boolean | undefined;
        };
        defaultInputValue: string;
        scrollbar: boolean | import("..").ScrollbarProps;
        border: boolean;
        popupVisible: boolean;
        defaultPopupVisible: boolean;
        fallbackOption: boolean | ((key: string | number) => boolean | import("..").TreeNodeData);
        showHeaderOnEmpty: boolean;
        showFooterOnEmpty: boolean;
        selectable: boolean | "leaf" | ((node: import("..").TreeNodeData, info: {
            isLeaf: boolean;
            level: number;
        }) => boolean);
        labelInValue: boolean;
        treeCheckable: boolean;
        treeCheckStrictly: boolean;
        treeCheckedStrategy: "all" | "child" | "parent";
        disableFilter: boolean;
    }>;
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
    disabled: {
        type: BooleanConstructor;
    };
    loading: {
        type: BooleanConstructor;
    };
    error: {
        type: BooleanConstructor;
    };
    size: {
        type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
    };
    border: {
        type: BooleanConstructor;
        default: boolean;
    };
    allowSearch: {
        type: import("vue").PropType<boolean | {
            retainInputValue?: boolean | undefined;
        }>;
        default: (props: import("../_utils/types").Data) => boolean;
    };
    allowClear: {
        type: BooleanConstructor;
    };
    placeholder: {
        type: StringConstructor;
    };
    maxTagCount: {
        type: NumberConstructor;
    };
    multiple: {
        type: BooleanConstructor;
    };
    defaultValue: {
        type: import("vue").PropType<string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[]>;
    };
    modelValue: {
        type: import("vue").PropType<string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[]>;
    };
    fieldNames: {
        type: import("vue").PropType<import("..").TreeFieldNames>;
    };
    data: {
        type: import("vue").PropType<import("..").TreeNodeData[]>;
        default: () => never[];
    };
    labelInValue: {
        type: BooleanConstructor;
    };
    treeCheckable: {
        type: BooleanConstructor;
    };
    treeCheckStrictly: {
        type: BooleanConstructor;
    };
    treeCheckedStrategy: {
        type: import("vue").PropType<"all" | "child" | "parent">;
        default: string;
    };
    treeProps: {
        type: import("vue").PropType<Partial<import("../tree/interface").TreeProps>>;
    };
    triggerProps: {
        type: import("vue").PropType<Partial<import("..").TriggerProps>>;
    };
    popupVisible: {
        type: BooleanConstructor;
        default: undefined;
    };
    defaultPopupVisible: {
        type: BooleanConstructor;
    };
    dropdownStyle: {
        type: import("vue").PropType<import("vue").CSSProperties>;
    };
    dropdownClassName: {
        type: import("vue").PropType<string | string[]>;
    };
    filterTreeNode: {
        type: import("vue").PropType<(searchKey: string, nodeData: import("..").TreeNodeData) => boolean>;
    };
    loadMore: {
        type: import("vue").PropType<(nodeData: import("..").TreeNodeData) => Promise<void>>;
    };
    disableFilter: {
        type: BooleanConstructor;
    };
    popupContainer: {
        type: import("vue").PropType<string | HTMLElement>;
    };
    fallbackOption: {
        type: import("vue").PropType<boolean | ((key: string | number) => boolean | import("..").TreeNodeData)>;
        default: boolean;
    };
    selectable: {
        type: import("vue").PropType<boolean | "leaf" | ((node: import("..").TreeNodeData, info: {
            isLeaf: boolean;
            level: number;
        }) => boolean)>;
        default: boolean;
    };
    scrollbar: {
        type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
        default: boolean;
    };
    showHeaderOnEmpty: {
        type: import("vue").PropType<boolean>;
        default: boolean;
    };
    showFooterOnEmpty: {
        type: import("vue").PropType<boolean>;
        default: boolean;
    };
    inputValue: {
        type: StringConstructor;
    };
    defaultInputValue: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    onClear?: (() => any) | undefined;
    onChange?: ((value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => any) | undefined;
    "onUpdate:inputValue"?: ((inputValue: string) => any) | undefined;
    onInputValueChange?: ((inputValue: string) => any) | undefined;
    "onUpdate:modelValue"?: ((value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => any) | undefined;
    "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
    onSearch?: ((searchKey: string) => any) | undefined;
    "onPopup-visible-change"?: ((visible: boolean) => any) | undefined;
}>, {
    refSelectView: import("vue").Ref<any, any>;
    prefixCls: string;
    TreeSelectEmpty: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }> | undefined;
    selectedValue: import("vue").ComputedRef<import("./interface").LabelValue[]>;
    selectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
    mergedDisabled: import("vue").ComputedRef<boolean>;
    searchValue: import("vue").ComputedRef<string>;
    panelVisible: import("vue").ComputedRef<boolean>;
    isEmpty: import("vue").ComputedRef<boolean | undefined>;
    computedFilterTreeNode: import("vue").ComputedRef<((node: import("..").TreeNodeData) => boolean) | undefined>;
    isMultiple: import("vue").ComputedRef<boolean>;
    selectViewValue: import("vue").ComputedRef<import("../_components/select-view/interface").SelectViewValue[]>;
    computedDropdownStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
    onSearchValueChange: (inputValue: string) => void;
    onSelectChange(newVal: string[]): void;
    onVisibleChange: (visible: boolean) => void;
    onInnerClear(): void;
    pickSubCompSlots: typeof import("../_utils/pick-sub-comp-slots").default;
    isSelectable: (node: import("..").TreeNodeData, info: {
        level: number;
        isLeaf: boolean;
    }) => boolean;
    isCheckable: import("vue").ComputedRef<false | ((node: import("..").TreeNodeData, info: {
        level: number;
        isLeaf: boolean;
    }) => boolean)>;
    onBlur: () => void;
    onItemRemove(id: string): void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    change: (value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => true;
    'update:modelValue': (value: string | number | (string | number)[] | import("./interface").LabelValue | import("./interface").LabelValue[] | undefined) => true;
    'update:inputValue': (inputValue: string) => true;
    'popup-visible-change': (visible: boolean) => true;
    'update:popupVisible': (visible: boolean) => true;
    search: (searchKey: string) => true;
    clear: () => true;
    inputValueChange: (inputValue: string) => true;
}, string, {
    disabled: boolean;
    error: boolean;
    allowClear: boolean;
    data: import("..").TreeNodeData[];
    loading: boolean;
    multiple: boolean;
    allowSearch: boolean | {
        retainInputValue?: boolean | undefined;
    };
    defaultInputValue: string;
    scrollbar: boolean | import("..").ScrollbarProps;
    border: boolean;
    popupVisible: boolean;
    defaultPopupVisible: boolean;
    fallbackOption: boolean | ((key: string | number) => boolean | import("..").TreeNodeData);
    showHeaderOnEmpty: boolean;
    showFooterOnEmpty: boolean;
    selectable: boolean | "leaf" | ((node: import("..").TreeNodeData, info: {
        isLeaf: boolean;
        level: number;
    }) => boolean);
    labelInValue: boolean;
    treeCheckable: boolean;
    treeCheckStrictly: boolean;
    treeCheckedStrategy: "all" | "child" | "parent";
    disableFilter: boolean;
}, {}, string, {}, {
    Trigger: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            popupVisible: {
                type: BooleanConstructor;
                default: undefined;
            };
            defaultPopupVisible: {
                type: BooleanConstructor;
                default: boolean;
            };
            trigger: {
                type: import("vue").PropType<"focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[]>;
                default: string;
            };
            position: {
                type: import("vue").PropType<"br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb">;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupOffset: {
                type: NumberConstructor;
                default: number;
            };
            popupTranslate: {
                type: import("vue").PropType<import("..").TriggerPopupTranslate>;
            };
            showArrow: {
                type: BooleanConstructor;
                default: boolean;
            };
            alignPoint: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupHoverStay: {
                type: BooleanConstructor;
                default: boolean;
            };
            blurToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            clickToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            clickOutsideToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            unmountOnClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            contentClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            contentStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            arrowClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            arrowStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            popupStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            animationName: {
                type: StringConstructor;
                default: string;
            };
            duration: {
                type: import("vue").PropType<number | {
                    enter: number;
                    leave: number;
                }>;
            };
            mouseEnterDelay: {
                type: NumberConstructor;
                default: number;
            };
            mouseLeaveDelay: {
                type: NumberConstructor;
                default: number;
            };
            focusDelay: {
                type: NumberConstructor;
                default: number;
            };
            autoFitPopupWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFitPopupMinWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFixPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupContainer: {
                type: import("vue").PropType<string | HTMLElement>;
            };
            updateAtScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFitTransformOrigin: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideEmpty: {
                type: BooleanConstructor;
                default: boolean;
            };
            openedClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            autoFitPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
            renderToBody: {
                type: BooleanConstructor;
                default: boolean;
            };
            preventFocus: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollToCloseDistance: {
                type: NumberConstructor;
                default: number;
            };
        }>> & Readonly<{
            onResize?: (() => any) | undefined;
            onHide?: (() => any) | undefined;
            onShow?: (() => any) | undefined;
            "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
            onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            'update:popupVisible': (visible: boolean) => true;
            popupVisibleChange: (visible: boolean) => true;
            show: () => true;
            hide: () => true;
            resize: () => true;
        }, import("vue").PublicProps, {
            disabled: boolean;
            position: "br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb";
            popupVisible: boolean;
            defaultPopupVisible: boolean;
            trigger: "focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[];
            popupOffset: number;
            showArrow: boolean;
            alignPoint: boolean;
            popupHoverStay: boolean;
            blurToClose: boolean;
            clickToClose: boolean;
            clickOutsideToClose: boolean;
            unmountOnClose: boolean;
            animationName: string;
            mouseEnterDelay: number;
            mouseLeaveDelay: number;
            focusDelay: number;
            autoFitPopupWidth: boolean;
            autoFitPopupMinWidth: boolean;
            autoFixPosition: boolean;
            updateAtScroll: boolean;
            autoFitTransformOrigin: boolean;
            hideEmpty: boolean;
            autoFitPosition: boolean;
            renderToBody: boolean;
            preventFocus: boolean;
            scrollToClose: boolean;
            scrollToCloseDistance: number;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            popupVisible: {
                type: BooleanConstructor;
                default: undefined;
            };
            defaultPopupVisible: {
                type: BooleanConstructor;
                default: boolean;
            };
            trigger: {
                type: import("vue").PropType<"focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[]>;
                default: string;
            };
            position: {
                type: import("vue").PropType<"br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb">;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupOffset: {
                type: NumberConstructor;
                default: number;
            };
            popupTranslate: {
                type: import("vue").PropType<import("..").TriggerPopupTranslate>;
            };
            showArrow: {
                type: BooleanConstructor;
                default: boolean;
            };
            alignPoint: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupHoverStay: {
                type: BooleanConstructor;
                default: boolean;
            };
            blurToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            clickToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            clickOutsideToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            unmountOnClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            contentClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            contentStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            arrowClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            arrowStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            popupStyle: {
                type: import("vue").PropType<import("vue").CSSProperties>;
            };
            animationName: {
                type: StringConstructor;
                default: string;
            };
            duration: {
                type: import("vue").PropType<number | {
                    enter: number;
                    leave: number;
                }>;
            };
            mouseEnterDelay: {
                type: NumberConstructor;
                default: number;
            };
            mouseLeaveDelay: {
                type: NumberConstructor;
                default: number;
            };
            focusDelay: {
                type: NumberConstructor;
                default: number;
            };
            autoFitPopupWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFitPopupMinWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFixPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
            popupContainer: {
                type: import("vue").PropType<string | HTMLElement>;
            };
            updateAtScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            autoFitTransformOrigin: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideEmpty: {
                type: BooleanConstructor;
                default: boolean;
            };
            openedClass: {
                type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            };
            autoFitPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
            renderToBody: {
                type: BooleanConstructor;
                default: boolean;
            };
            preventFocus: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollToClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollToCloseDistance: {
                type: NumberConstructor;
                default: number;
            };
        }>> & Readonly<{
            onResize?: (() => any) | undefined;
            onHide?: (() => any) | undefined;
            onShow?: (() => any) | undefined;
            "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
            onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
            disabled: boolean;
            position: "br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb";
            popupVisible: boolean;
            defaultPopupVisible: boolean;
            trigger: "focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[];
            popupOffset: number;
            showArrow: boolean;
            alignPoint: boolean;
            popupHoverStay: boolean;
            blurToClose: boolean;
            clickToClose: boolean;
            clickOutsideToClose: boolean;
            unmountOnClose: boolean;
            animationName: string;
            mouseEnterDelay: number;
            mouseLeaveDelay: number;
            focusDelay: number;
            autoFitPopupWidth: boolean;
            autoFitPopupMinWidth: boolean;
            autoFixPosition: boolean;
            updateAtScroll: boolean;
            autoFitTransformOrigin: boolean;
            hideEmpty: boolean;
            autoFitPosition: boolean;
            renderToBody: boolean;
            preventFocus: boolean;
            scrollToClose: boolean;
            scrollToCloseDistance: number;
        }>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        popupVisible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultPopupVisible: {
            type: BooleanConstructor;
            default: boolean;
        };
        trigger: {
            type: import("vue").PropType<"focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[]>;
            default: string;
        };
        position: {
            type: import("vue").PropType<"br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb">;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        popupOffset: {
            type: NumberConstructor;
            default: number;
        };
        popupTranslate: {
            type: import("vue").PropType<import("..").TriggerPopupTranslate>;
        };
        showArrow: {
            type: BooleanConstructor;
            default: boolean;
        };
        alignPoint: {
            type: BooleanConstructor;
            default: boolean;
        };
        popupHoverStay: {
            type: BooleanConstructor;
            default: boolean;
        };
        blurToClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        clickToClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        clickOutsideToClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        unmountOnClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        contentClass: {
            type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
        };
        contentStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        arrowClass: {
            type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
        };
        arrowStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        popupStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        animationName: {
            type: StringConstructor;
            default: string;
        };
        duration: {
            type: import("vue").PropType<number | {
                enter: number;
                leave: number;
            }>;
        };
        mouseEnterDelay: {
            type: NumberConstructor;
            default: number;
        };
        mouseLeaveDelay: {
            type: NumberConstructor;
            default: number;
        };
        focusDelay: {
            type: NumberConstructor;
            default: number;
        };
        autoFitPopupWidth: {
            type: BooleanConstructor;
            default: boolean;
        };
        autoFitPopupMinWidth: {
            type: BooleanConstructor;
            default: boolean;
        };
        autoFixPosition: {
            type: BooleanConstructor;
            default: boolean;
        };
        popupContainer: {
            type: import("vue").PropType<string | HTMLElement>;
        };
        updateAtScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        autoFitTransformOrigin: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideEmpty: {
            type: BooleanConstructor;
            default: boolean;
        };
        openedClass: {
            type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
        };
        autoFitPosition: {
            type: BooleanConstructor;
            default: boolean;
        };
        renderToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        preventFocus: {
            type: BooleanConstructor;
            default: boolean;
        };
        scrollToClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        scrollToCloseDistance: {
            type: NumberConstructor;
            default: number;
        };
    }>> & Readonly<{
        onResize?: (() => any) | undefined;
        onHide?: (() => any) | undefined;
        onShow?: (() => any) | undefined;
        "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
        onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:popupVisible': (visible: boolean) => true;
        popupVisibleChange: (visible: boolean) => true;
        show: () => true;
        hide: () => true;
        resize: () => true;
    }, string, {
        disabled: boolean;
        position: "br" | "rt" | "tr" | "top" | "bottom" | "left" | "right" | "tl" | "bl" | "lt" | "lb" | "rb";
        popupVisible: boolean;
        defaultPopupVisible: boolean;
        trigger: "focus" | "hover" | "click" | "contextMenu" | ("focus" | "hover" | "click" | "contextMenu")[];
        popupOffset: number;
        showArrow: boolean;
        alignPoint: boolean;
        popupHoverStay: boolean;
        blurToClose: boolean;
        clickToClose: boolean;
        clickOutsideToClose: boolean;
        unmountOnClose: boolean;
        animationName: string;
        mouseEnterDelay: number;
        mouseLeaveDelay: number;
        focusDelay: number;
        autoFitPopupWidth: boolean;
        autoFitPopupMinWidth: boolean;
        autoFixPosition: boolean;
        updateAtScroll: boolean;
        autoFitTransformOrigin: boolean;
        hideEmpty: boolean;
        autoFitPosition: boolean;
        renderToBody: boolean;
        preventFocus: boolean;
        scrollToClose: boolean;
        scrollToCloseDistance: number;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
        install: (app: App<any>, options?: ArcoOptions | undefined) => void;
    };
    SelectView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        modelValue: {
            type: import("vue").PropType<import("../_components/select-view/interface").SelectViewValue[]>;
            required: true;
        };
        inputValue: StringConstructor;
        placeholder: StringConstructor;
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        error: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        opened: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
        };
        bordered: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowCreate: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowSearch: {
            type: BooleanConstructor;
            default: (props: import("../_utils/types").Data) => boolean;
        };
        maxTagCount: {
            type: NumberConstructor;
            default: number;
        };
        tagNowrap: {
            type: BooleanConstructor;
            default: boolean;
        };
        retainInputValue: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        inputRef: import("vue").ComputedRef<HTMLInputElement>;
        handleFocus: (ev: FocusEvent) => void;
        handleBlur: (ev: FocusEvent) => void;
        render: () => import("vue/jsx-runtime").JSX.Element;
    }, {}, {}, {
        focus(): void;
        blur(): void;
    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "blur" | "focus" | "remove")[], "clear" | "blur" | "focus" | "remove", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        modelValue: {
            type: import("vue").PropType<import("../_components/select-view/interface").SelectViewValue[]>;
            required: true;
        };
        inputValue: StringConstructor;
        placeholder: StringConstructor;
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        error: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        opened: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
        };
        bordered: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowCreate: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowSearch: {
            type: BooleanConstructor;
            default: (props: import("../_utils/types").Data) => boolean;
        };
        maxTagCount: {
            type: NumberConstructor;
            default: number;
        };
        tagNowrap: {
            type: BooleanConstructor;
            default: boolean;
        };
        retainInputValue: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onClear?: ((...args: any[]) => any) | undefined;
        onBlur?: ((...args: any[]) => any) | undefined;
        onFocus?: ((...args: any[]) => any) | undefined;
        onRemove?: ((...args: any[]) => any) | undefined;
    }>, {
        disabled: boolean;
        error: boolean;
        allowClear: boolean;
        retainInputValue: boolean;
        loading: boolean;
        opened: boolean;
        bordered: boolean;
        multiple: boolean;
        allowCreate: boolean;
        allowSearch: boolean;
        maxTagCount: number;
        tagNowrap: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Panel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        treeProps: {
            type: import("vue").PropType<Partial<import("../tree/interface").TreeProps>>;
            default: () => {};
        };
        selectedKeys: {
            type: import("vue").PropType<import("../tree/interface").TreeNodeKey[]>;
        };
        showCheckable: {
            type: BooleanConstructor;
        };
        treeSlots: {
            type: import("vue").PropType<Readonly<{
                [name: string]: import("vue").Slot<any> | undefined;
            }>>;
            default: () => {};
        };
        scrollbar: {
            type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
            default: boolean;
        };
    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        treeProps: {
            type: import("vue").PropType<Partial<import("../tree/interface").TreeProps>>;
            default: () => {};
        };
        selectedKeys: {
            type: import("vue").PropType<import("../tree/interface").TreeNodeKey[]>;
        };
        showCheckable: {
            type: BooleanConstructor;
        };
        treeSlots: {
            type: import("vue").PropType<Readonly<{
                [name: string]: import("vue").Slot<any> | undefined;
            }>>;
            default: () => {};
        };
        scrollbar: {
            type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
            default: boolean;
        };
    }>> & Readonly<{
        onChange?: ((...args: any[]) => any) | undefined;
    }>, {
        scrollbar: boolean | import("..").ScrollbarProps;
        treeProps: Partial<import("../tree/interface").TreeProps>;
        showCheckable: boolean;
        treeSlots: Readonly<{
            [name: string]: import("vue").Slot<any> | undefined;
        }>;
    }, {}, {
        Tree: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                    default: string;
                };
                blockNode: {
                    type: BooleanConstructor;
                };
                defaultExpandAll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                };
                checkable: {
                    type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean)>;
                    default: boolean;
                };
                selectable: {
                    type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean)>;
                    default: boolean;
                };
                checkStrictly: {
                    type: BooleanConstructor;
                };
                checkedStrategy: {
                    type: import("vue").PropType<"all" | "child" | "parent">;
                    default: string;
                };
                defaultSelectedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                selectedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                defaultCheckedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                checkedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                defaultExpandedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                expandedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                data: {
                    type: import("vue").PropType<import("..").TreeNodeData[]>;
                    default: () => never[];
                };
                fieldNames: {
                    type: import("vue").PropType<import("..").TreeFieldNames>;
                };
                showLine: {
                    type: BooleanConstructor;
                };
                loadMore: {
                    type: import("vue").PropType<(node: import("..").TreeNodeData) => Promise<void>>;
                };
                draggable: {
                    type: BooleanConstructor;
                };
                allowDrop: {
                    type: import("vue").PropType<(options: {
                        dropNode: import("..").TreeNodeData;
                        dropPosition: 0 | 1 | -1;
                    }) => boolean>;
                };
                filterTreeNode: {
                    type: import("vue").PropType<import("../tree/interface").FilterTreeNode>;
                };
                searchValue: {
                    type: StringConstructor;
                    default: string;
                };
                virtualListProps: {
                    type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                };
                defaultExpandSelected: {
                    type: BooleanConstructor;
                };
                defaultExpandChecked: {
                    type: BooleanConstructor;
                };
                autoExpandParent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                halfCheckedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                onlyCheckLeaf: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                animation: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                actionOnNodeClick: {
                    type: import("vue").PropType<"expand">;
                };
                disableSelectActionOnly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onSelect?: ((selectedKeys: (string | number)[], data: {
                    selected?: boolean | undefined;
                    selectedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                onDrop?: ((data: {
                    e: DragEvent;
                    dragNode: import("..").TreeNodeData;
                    dropNode: import("..").TreeNodeData;
                    dropPosition: number;
                }) => any) | undefined;
                "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
                "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
                onExpand?: ((expandKeys: (string | number)[], data: {
                    expanded?: boolean | undefined;
                    expandedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                onCheck?: ((checkedKeys: (string | number)[], data: {
                    checked?: boolean | undefined;
                    checkedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    halfCheckedKeys: (string | number)[];
                    halfCheckedNodes: import("..").TreeNodeData[];
                    e?: Event | undefined;
                }) => any) | undefined;
                onDragStart?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragOver?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragLeave?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragEnd?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
                "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
            }>, {
                classNames: import("vue").ComputedRef<(string | {
                    [x: string]: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                })[]>;
                visibleTreeNodeList: import("vue").ComputedRef<import("../tree/interface").Node[]>;
                treeContext: {
                    treeProps: {
                        readonly size: "mini" | "small" | "medium" | "large";
                        readonly data: {
                            key?: string | number | undefined;
                            title?: string | undefined;
                            selectable?: boolean | undefined;
                            disabled?: boolean | undefined;
                            disableCheckbox?: boolean | undefined;
                            checkable?: boolean | undefined;
                            draggable?: boolean | undefined;
                            isLeaf?: boolean | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            children?: any[] | undefined;
                        }[];
                        readonly multiple: boolean;
                        readonly animation: boolean;
                        readonly draggable: boolean;
                        readonly checkStrictly: boolean;
                        readonly checkable: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                        readonly showLine: boolean;
                        readonly selectable: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                        readonly blockNode: boolean;
                        readonly defaultExpandAll: boolean;
                        readonly checkedStrategy: "all" | "child" | "parent";
                        readonly searchValue: string;
                        readonly defaultExpandSelected: boolean;
                        readonly defaultExpandChecked: boolean;
                        readonly autoExpandParent: boolean;
                        readonly onlyCheckLeaf: boolean;
                        readonly disableSelectActionOnly: boolean;
                        readonly fieldNames: {
                            key?: string | undefined;
                            title?: string | undefined;
                            disabled?: string | undefined;
                            children?: string | undefined;
                            isLeaf?: string | undefined;
                            disableCheckbox?: string | undefined;
                            checkable?: string | undefined;
                            icon?: string | undefined;
                        } | undefined;
                        readonly virtualListProps: {
                            height?: string | number | undefined;
                            threshold?: number | undefined;
                            isStaticItemHeight?: boolean | undefined;
                            fixedSize?: boolean | undefined;
                            estimatedSize?: number | undefined;
                            buffer?: number | undefined;
                            data?: unknown[] | undefined;
                            itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
                            component?: keyof HTMLElementTagNameMap | undefined;
                        } | undefined;
                        readonly loadMore: ((node: import("..").TreeNodeData) => Promise<void>) | undefined;
                        readonly selectedKeys: (string | number)[] | undefined;
                        readonly defaultSelectedKeys: (string | number)[] | undefined;
                        readonly expandedKeys: (string | number)[] | undefined;
                        readonly defaultExpandedKeys: (string | number)[] | undefined;
                        readonly checkedKeys: (string | number)[] | undefined;
                        readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                        readonly allowDrop: ((options: {
                            dropNode: import("..").TreeNodeData;
                            dropPosition: 0 | 1 | -1;
                        }) => boolean) | undefined;
                        readonly defaultCheckedKeys: (string | number)[] | undefined;
                        readonly halfCheckedKeys: (string | number)[] | undefined;
                        readonly actionOnNodeClick: "expand" | undefined;
                        readonly onSelect: ((selectedKeys: (string | number)[], data: {
                            selected?: boolean | undefined;
                            selectedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onDrop: ((data: {
                            e: DragEvent;
                            dragNode: import("..").TreeNodeData;
                            dropNode: import("..").TreeNodeData;
                            dropPosition: number;
                        }) => any) | undefined;
                        readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
                        readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
                        readonly onExpand: ((expandKeys: (string | number)[], data: {
                            expanded?: boolean | undefined;
                            expandedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onCheck: ((checkedKeys: (string | number)[], data: {
                            checked?: boolean | undefined;
                            checkedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            halfCheckedKeys: (string | number)[];
                            halfCheckedNodes: import("..").TreeNodeData[];
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onDragStart: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragOver: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragLeave: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragEnd: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
                        readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                    };
                    switcherIcon: import("vue").Slot<any> | undefined;
                    loadingIcon: import("vue").Slot<any> | undefined;
                    dragIcon: import("vue").Slot<any> | undefined;
                    nodeIcon: import("vue").Slot<any> | undefined;
                    nodeTitle: import("vue").Slot<any> | undefined;
                    nodeExtra: import("vue").Slot<any> | undefined;
                    treeData: {
                        key: import("../tree/interface").TreeNodeKey;
                        treeNodeProps: {
                            selectable: boolean;
                            disabled: boolean;
                            disableCheckbox: boolean;
                            checkable: boolean;
                            draggable: boolean;
                            isLeaf: boolean;
                            isTail: boolean;
                            blockNode: boolean;
                            showLine: boolean;
                            level: number;
                            lineless: boolean[];
                            title?: string | undefined;
                            key?: string | number | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                        };
                        treeNodeData: {
                            key?: string | number | undefined;
                            title?: string | undefined;
                            selectable?: boolean | undefined;
                            disabled?: boolean | undefined;
                            disableCheckbox?: boolean | undefined;
                            checkable?: boolean | undefined;
                            draggable?: boolean | undefined;
                            isLeaf?: boolean | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            children?: any[] | undefined;
                        };
                        parent?: any | undefined;
                        parentKey?: import("../tree/interface").TreeNodeKey | undefined;
                        pathParentKeys: import("../tree/interface").TreeNodeKey[];
                        children?: any[] | undefined;
                        selectable: boolean;
                        disabled: boolean;
                        disableCheckbox: boolean;
                        checkable: boolean;
                        draggable: boolean;
                        isLeaf: boolean;
                        isTail: boolean;
                        blockNode: boolean;
                        showLine: boolean;
                        level: number;
                        lineless: boolean[];
                        title?: string | undefined;
                        icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                    }[];
                    flattenTreeData: import("../tree/interface").Node[];
                    key2TreeNode: import("../tree/interface").Key2TreeNode;
                    checkedKeys: import("../tree/interface").TreeNodeKey[];
                    indeterminateKeys: import("../tree/interface").TreeNodeKey[];
                    selectedKeys: import("../tree/interface").TreeNodeKey[];
                    expandedKeys: import("../tree/interface").TreeNodeKey[];
                    loadingKeys: import("../tree/interface").TreeNodeKey[];
                    currentExpandKeys: import("../tree/interface").TreeNodeKey[];
                    onLoadMore: ((key: import("../tree/interface").TreeNodeKey) => Promise<void>) | undefined;
                    filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                    onCheck: (checked: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                    onSelect: (key: import("../tree/interface").TreeNodeKey, e: Event) => void;
                    onExpand: (expanded: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                    onExpandEnd: (key: import("../tree/interface").TreeNodeKey) => void;
                    allowDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                    onDragStart: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragEnd: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragOver: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragLeave: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: number, e: DragEvent) => void;
                };
                virtualListRef: import("vue").Ref<any, any>;
                computedSelectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedExpandedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedCheckedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedIndeterminateKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                getPublicCheckedKeys: (rawCheckedKeys: import("../tree/interface").TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => import("../tree/interface").TreeNodeKey[];
                getNodes: (keys: import("../tree/interface").TreeNodeKey[]) => (import("..").TreeNodeData | undefined)[];
                internalCheckNodes: (keys: import("../tree/interface").TreeNodeKey[], checked: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetCheckedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                internalSelectNodes: (keys: import("../tree/interface").TreeNodeKey[], selected: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetSelectedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                internalExpandNodes: (keys: import("../tree/interface").TreeNodeKey[], expanded: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetExpandedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
            }, {}, {}, {
                toggleCheck(key: import("../tree/interface").TreeNodeKey, e: Event): void;
                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
                getSelectedNodes(): (import("..").TreeNodeData | undefined)[];
                getCheckedNodes(options?: {
                    checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                    includeHalfChecked?: boolean | undefined;
                }): (import("..").TreeNodeData | undefined)[];
                getHalfCheckedNodes(): (import("..").TreeNodeData | undefined)[];
                getExpandedNodes(): (import("..").TreeNodeData | undefined)[];
                checkAll(checked?: boolean): void;
                checkNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
                selectAll(selected?: boolean): void;
                selectNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], selected?: boolean): void;
                expandAll(expanded?: boolean): void;
                expandNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], expanded?: boolean): void;
            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                select: (selectedKeys: (string | number)[], data: {
                    selected?: boolean | undefined;
                    selectedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => true;
                'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
                check: (checkedKeys: (string | number)[], data: {
                    checked?: boolean | undefined;
                    checkedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    halfCheckedKeys: (string | number)[];
                    halfCheckedNodes: import("..").TreeNodeData[];
                    e?: Event | undefined;
                }) => true;
                'update:checkedKeys': (checkedKeys: (string | number)[]) => true;
                'update:halfCheckedKeys': (halfCheckedKeys: (string | number)[]) => true;
                expand: (expandKeys: (string | number)[], data: {
                    expanded?: boolean | undefined;
                    expandedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => true;
                'update:expandedKeys': (expandKeys: (string | number)[]) => true;
                dragStart: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                dragEnd: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                dragOver: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                dragLeave: (ev: DragEvent, node: import("..").TreeNodeData) => true;
                drop: (data: {
                    e: DragEvent;
                    dragNode: import("..").TreeNodeData;
                    dropNode: import("..").TreeNodeData;
                    dropPosition: number;
                }) => true;
            }, import("vue").PublicProps, {
                size: "mini" | "small" | "medium" | "large";
                data: import("..").TreeNodeData[];
                multiple: boolean;
                animation: boolean;
                draggable: boolean;
                checkStrictly: boolean;
                checkable: boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
                showLine: boolean;
                selectable: boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
                blockNode: boolean;
                defaultExpandAll: boolean;
                checkedStrategy: "all" | "child" | "parent";
                searchValue: string;
                defaultExpandSelected: boolean;
                defaultExpandChecked: boolean;
                autoExpandParent: boolean;
                onlyCheckLeaf: boolean;
                disableSelectActionOnly: boolean;
            }, true, {}, {}, {
                VirtualList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    data: {
                        type: import("vue").PropType<Record<string, any>[]>;
                        default: () => never[];
                    };
                    threshold: {
                        type: NumberConstructor;
                        default: number;
                    };
                    itemKey: {
                        type: StringConstructor;
                        default: string;
                    };
                    fixedSize: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    estimatedSize: {
                        type: NumberConstructor;
                        default: number;
                    };
                    buffer: {
                        type: NumberConstructor;
                        default: number;
                    };
                    component: {
                        type: (ObjectConstructor | StringConstructor)[];
                        default: string;
                    };
                    listAttrs: {
                        type: ObjectConstructor;
                    };
                    contentAttrs: {
                        type: ObjectConstructor;
                    };
                    paddingPosition: {
                        type: StringConstructor;
                        default: string;
                    };
                }>, {
                    prefixCls: string;
                    containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    frontPadding: import("vue").ComputedRef<number>;
                    currentList: import("vue").ComputedRef<Record<string, any>[]>;
                    behindPadding: import("vue").ComputedRef<number>;
                    onScroll: (ev: Event) => void;
                    setItemSize: (key: string | number, size: number) => void;
                    hasItemSize: (key: string | number) => boolean;
                    start: import("vue").Ref<number, number>;
                    scrollTo: (options: import("../_components/virtual-list-v2/interface").ScrollOptions) => void;
                    style: import("vue").ComputedRef<{
                        height: string;
                        overflow: string;
                    }>;
                    mergedComponent: import("vue").ComputedRef<{
                        container: string;
                        list: string;
                        content: string;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    scroll: (ev: Event) => true;
                    reachBottom: (ev: Event) => true;
                }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    data: {
                        type: import("vue").PropType<Record<string, any>[]>;
                        default: () => never[];
                    };
                    threshold: {
                        type: NumberConstructor;
                        default: number;
                    };
                    itemKey: {
                        type: StringConstructor;
                        default: string;
                    };
                    fixedSize: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    estimatedSize: {
                        type: NumberConstructor;
                        default: number;
                    };
                    buffer: {
                        type: NumberConstructor;
                        default: number;
                    };
                    component: {
                        type: (ObjectConstructor | StringConstructor)[];
                        default: string;
                    };
                    listAttrs: {
                        type: ObjectConstructor;
                    };
                    contentAttrs: {
                        type: ObjectConstructor;
                    };
                    paddingPosition: {
                        type: StringConstructor;
                        default: string;
                    };
                }>> & Readonly<{
                    onScroll?: ((ev: Event) => any) | undefined;
                    onReachBottom?: ((ev: Event) => any) | undefined;
                }>, {
                    data: Record<string, any>[];
                    height: string | number;
                    threshold: number;
                    itemKey: string;
                    fixedSize: boolean;
                    estimatedSize: number;
                    buffer: number;
                    component: string | Record<string, any>;
                    paddingPosition: string;
                }, {}, {
                    VirtualListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        hasItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                        setItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        hasItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                        setItemSize: {
                            type: FunctionConstructor;
                            required: true;
                        };
                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                TreeNode: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
                    [x: string]: 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<{
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                    default: string;
                };
                blockNode: {
                    type: BooleanConstructor;
                };
                defaultExpandAll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                };
                checkable: {
                    type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean)>;
                    default: boolean;
                };
                selectable: {
                    type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean)>;
                    default: boolean;
                };
                checkStrictly: {
                    type: BooleanConstructor;
                };
                checkedStrategy: {
                    type: import("vue").PropType<"all" | "child" | "parent">;
                    default: string;
                };
                defaultSelectedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                selectedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                defaultCheckedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                checkedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                defaultExpandedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                expandedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                data: {
                    type: import("vue").PropType<import("..").TreeNodeData[]>;
                    default: () => never[];
                };
                fieldNames: {
                    type: import("vue").PropType<import("..").TreeFieldNames>;
                };
                showLine: {
                    type: BooleanConstructor;
                };
                loadMore: {
                    type: import("vue").PropType<(node: import("..").TreeNodeData) => Promise<void>>;
                };
                draggable: {
                    type: BooleanConstructor;
                };
                allowDrop: {
                    type: import("vue").PropType<(options: {
                        dropNode: import("..").TreeNodeData;
                        dropPosition: 0 | 1 | -1;
                    }) => boolean>;
                };
                filterTreeNode: {
                    type: import("vue").PropType<import("../tree/interface").FilterTreeNode>;
                };
                searchValue: {
                    type: StringConstructor;
                    default: string;
                };
                virtualListProps: {
                    type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                };
                defaultExpandSelected: {
                    type: BooleanConstructor;
                };
                defaultExpandChecked: {
                    type: BooleanConstructor;
                };
                autoExpandParent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                halfCheckedKeys: {
                    type: import("vue").PropType<(string | number)[]>;
                };
                onlyCheckLeaf: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                animation: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                actionOnNodeClick: {
                    type: import("vue").PropType<"expand">;
                };
                disableSelectActionOnly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onSelect?: ((selectedKeys: (string | number)[], data: {
                    selected?: boolean | undefined;
                    selectedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                onDrop?: ((data: {
                    e: DragEvent;
                    dragNode: import("..").TreeNodeData;
                    dropNode: import("..").TreeNodeData;
                    dropPosition: number;
                }) => any) | undefined;
                "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
                "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
                onExpand?: ((expandKeys: (string | number)[], data: {
                    expanded?: boolean | undefined;
                    expandedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                onCheck?: ((checkedKeys: (string | number)[], data: {
                    checked?: boolean | undefined;
                    checkedNodes: import("..").TreeNodeData[];
                    node?: import("..").TreeNodeData | undefined;
                    halfCheckedKeys: (string | number)[];
                    halfCheckedNodes: import("..").TreeNodeData[];
                    e?: Event | undefined;
                }) => any) | undefined;
                onDragStart?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragOver?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragLeave?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                onDragEnd?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
                "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
            }>, {
                classNames: import("vue").ComputedRef<(string | {
                    [x: string]: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                })[]>;
                visibleTreeNodeList: import("vue").ComputedRef<import("../tree/interface").Node[]>;
                treeContext: {
                    treeProps: {
                        readonly size: "mini" | "small" | "medium" | "large";
                        readonly data: {
                            key?: string | number | undefined;
                            title?: string | undefined;
                            selectable?: boolean | undefined;
                            disabled?: boolean | undefined;
                            disableCheckbox?: boolean | undefined;
                            checkable?: boolean | undefined;
                            draggable?: boolean | undefined;
                            isLeaf?: boolean | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            children?: any[] | undefined;
                        }[];
                        readonly multiple: boolean;
                        readonly animation: boolean;
                        readonly draggable: boolean;
                        readonly checkStrictly: boolean;
                        readonly checkable: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                        readonly showLine: boolean;
                        readonly selectable: boolean | ((node: import("..").TreeNodeData, info: {
                            level: number;
                            isLeaf: boolean;
                        }) => boolean);
                        readonly blockNode: boolean;
                        readonly defaultExpandAll: boolean;
                        readonly checkedStrategy: "all" | "child" | "parent";
                        readonly searchValue: string;
                        readonly defaultExpandSelected: boolean;
                        readonly defaultExpandChecked: boolean;
                        readonly autoExpandParent: boolean;
                        readonly onlyCheckLeaf: boolean;
                        readonly disableSelectActionOnly: boolean;
                        readonly fieldNames: {
                            key?: string | undefined;
                            title?: string | undefined;
                            disabled?: string | undefined;
                            children?: string | undefined;
                            isLeaf?: string | undefined;
                            disableCheckbox?: string | undefined;
                            checkable?: string | undefined;
                            icon?: string | undefined;
                        } | undefined;
                        readonly virtualListProps: {
                            height?: string | number | undefined;
                            threshold?: number | undefined;
                            isStaticItemHeight?: boolean | undefined;
                            fixedSize?: boolean | undefined;
                            estimatedSize?: number | undefined;
                            buffer?: number | undefined;
                            data?: unknown[] | undefined;
                            itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
                            component?: keyof HTMLElementTagNameMap | undefined;
                        } | undefined;
                        readonly loadMore: ((node: import("..").TreeNodeData) => Promise<void>) | undefined;
                        readonly selectedKeys: (string | number)[] | undefined;
                        readonly defaultSelectedKeys: (string | number)[] | undefined;
                        readonly expandedKeys: (string | number)[] | undefined;
                        readonly defaultExpandedKeys: (string | number)[] | undefined;
                        readonly checkedKeys: (string | number)[] | undefined;
                        readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                        readonly allowDrop: ((options: {
                            dropNode: import("..").TreeNodeData;
                            dropPosition: 0 | 1 | -1;
                        }) => boolean) | undefined;
                        readonly defaultCheckedKeys: (string | number)[] | undefined;
                        readonly halfCheckedKeys: (string | number)[] | undefined;
                        readonly actionOnNodeClick: "expand" | undefined;
                        readonly onSelect: ((selectedKeys: (string | number)[], data: {
                            selected?: boolean | undefined;
                            selectedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onDrop: ((data: {
                            e: DragEvent;
                            dragNode: import("..").TreeNodeData;
                            dropNode: import("..").TreeNodeData;
                            dropPosition: number;
                        }) => any) | undefined;
                        readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
                        readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
                        readonly onExpand: ((expandKeys: (string | number)[], data: {
                            expanded?: boolean | undefined;
                            expandedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onCheck: ((checkedKeys: (string | number)[], data: {
                            checked?: boolean | undefined;
                            checkedNodes: import("..").TreeNodeData[];
                            node?: import("..").TreeNodeData | undefined;
                            halfCheckedKeys: (string | number)[];
                            halfCheckedNodes: import("..").TreeNodeData[];
                            e?: Event | undefined;
                        }) => any) | undefined;
                        readonly onDragStart: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragOver: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragLeave: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly onDragEnd: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                        readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
                        readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                    };
                    switcherIcon: import("vue").Slot<any> | undefined;
                    loadingIcon: import("vue").Slot<any> | undefined;
                    dragIcon: import("vue").Slot<any> | undefined;
                    nodeIcon: import("vue").Slot<any> | undefined;
                    nodeTitle: import("vue").Slot<any> | undefined;
                    nodeExtra: import("vue").Slot<any> | undefined;
                    treeData: {
                        key: import("../tree/interface").TreeNodeKey;
                        treeNodeProps: {
                            selectable: boolean;
                            disabled: boolean;
                            disableCheckbox: boolean;
                            checkable: boolean;
                            draggable: boolean;
                            isLeaf: boolean;
                            isTail: boolean;
                            blockNode: boolean;
                            showLine: boolean;
                            level: number;
                            lineless: boolean[];
                            title?: string | undefined;
                            key?: string | number | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                        };
                        treeNodeData: {
                            key?: string | number | undefined;
                            title?: string | undefined;
                            selectable?: boolean | undefined;
                            disabled?: boolean | undefined;
                            disableCheckbox?: boolean | undefined;
                            checkable?: boolean | undefined;
                            draggable?: boolean | undefined;
                            isLeaf?: boolean | undefined;
                            icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>) | undefined;
                            children?: any[] | undefined;
                        };
                        parent?: any | undefined;
                        parentKey?: import("../tree/interface").TreeNodeKey | undefined;
                        pathParentKeys: import("../tree/interface").TreeNodeKey[];
                        children?: any[] | undefined;
                        selectable: boolean;
                        disabled: boolean;
                        disableCheckbox: boolean;
                        checkable: boolean;
                        draggable: boolean;
                        isLeaf: boolean;
                        isTail: boolean;
                        blockNode: boolean;
                        showLine: boolean;
                        level: number;
                        lineless: boolean[];
                        title?: string | undefined;
                        icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                    }[];
                    flattenTreeData: import("../tree/interface").Node[];
                    key2TreeNode: import("../tree/interface").Key2TreeNode;
                    checkedKeys: import("../tree/interface").TreeNodeKey[];
                    indeterminateKeys: import("../tree/interface").TreeNodeKey[];
                    selectedKeys: import("../tree/interface").TreeNodeKey[];
                    expandedKeys: import("../tree/interface").TreeNodeKey[];
                    loadingKeys: import("../tree/interface").TreeNodeKey[];
                    currentExpandKeys: import("../tree/interface").TreeNodeKey[];
                    onLoadMore: ((key: import("../tree/interface").TreeNodeKey) => Promise<void>) | undefined;
                    filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                    onCheck: (checked: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                    onSelect: (key: import("../tree/interface").TreeNodeKey, e: Event) => void;
                    onExpand: (expanded: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                    onExpandEnd: (key: import("../tree/interface").TreeNodeKey) => void;
                    allowDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                    onDragStart: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragEnd: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragOver: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDragLeave: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                    onDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: number, e: DragEvent) => void;
                };
                virtualListRef: import("vue").Ref<any, any>;
                computedSelectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedExpandedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedCheckedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                computedIndeterminateKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
                getPublicCheckedKeys: (rawCheckedKeys: import("../tree/interface").TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => import("../tree/interface").TreeNodeKey[];
                getNodes: (keys: import("../tree/interface").TreeNodeKey[]) => (import("..").TreeNodeData | undefined)[];
                internalCheckNodes: (keys: import("../tree/interface").TreeNodeKey[], checked: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetCheckedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                internalSelectNodes: (keys: import("../tree/interface").TreeNodeKey[], selected: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetSelectedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
                internalExpandNodes: (keys: import("../tree/interface").TreeNodeKey[], expanded: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
                internalSetExpandedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
            }, {}, {}, {
                toggleCheck(key: import("../tree/interface").TreeNodeKey, e: Event): void;
                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
                getSelectedNodes(): (import("..").TreeNodeData | undefined)[];
                getCheckedNodes(options?: {
                    checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                    includeHalfChecked?: boolean | undefined;
                }): (import("..").TreeNodeData | undefined)[];
                getHalfCheckedNodes(): (import("..").TreeNodeData | undefined)[];
                getExpandedNodes(): (import("..").TreeNodeData | undefined)[];
                checkAll(checked?: boolean): void;
                checkNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
                selectAll(selected?: boolean): void;
                selectNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], selected?: boolean): void;
                expandAll(expanded?: boolean): void;
                expandNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], expanded?: boolean): void;
            }, {
                size: "mini" | "small" | "medium" | "large";
                data: import("..").TreeNodeData[];
                multiple: boolean;
                animation: boolean;
                draggable: boolean;
                checkStrictly: boolean;
                checkable: boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
                showLine: boolean;
                selectable: boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
                blockNode: boolean;
                defaultExpandAll: boolean;
                checkedStrategy: "all" | "child" | "parent";
                searchValue: string;
                defaultExpandSelected: boolean;
                defaultExpandChecked: boolean;
                autoExpandParent: boolean;
                onlyCheckLeaf: boolean;
                disableSelectActionOnly: boolean;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                default: string;
            };
            blockNode: {
                type: BooleanConstructor;
            };
            defaultExpandAll: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
            };
            checkable: {
                type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean)>;
                default: boolean;
            };
            selectable: {
                type: import("vue").PropType<boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean)>;
                default: boolean;
            };
            checkStrictly: {
                type: BooleanConstructor;
            };
            checkedStrategy: {
                type: import("vue").PropType<"all" | "child" | "parent">;
                default: string;
            };
            defaultSelectedKeys: {
                type: import("vue").PropType<(string | number)[]>;
            };
            selectedKeys: {
                type: import("vue").PropType<(string | number)[]>;
            };
            defaultCheckedKeys: {
                type: import("vue").PropType<(string | number)[]>;
            };
            checkedKeys: {
                type: import("vue").PropType<(string | number)[]>;
            };
            defaultExpandedKeys: {
                type: import("vue").PropType<(string | number)[]>;
            };
            expandedKeys: {
                type: import("vue").PropType<(string | number)[]>;
            };
            data: {
                type: import("vue").PropType<import("..").TreeNodeData[]>;
                default: () => never[];
            };
            fieldNames: {
                type: import("vue").PropType<import("..").TreeFieldNames>;
            };
            showLine: {
                type: BooleanConstructor;
            };
            loadMore: {
                type: import("vue").PropType<(node: import("..").TreeNodeData) => Promise<void>>;
            };
            draggable: {
                type: BooleanConstructor;
            };
            allowDrop: {
                type: import("vue").PropType<(options: {
                    dropNode: import("..").TreeNodeData;
                    dropPosition: 0 | 1 | -1;
                }) => boolean>;
            };
            filterTreeNode: {
                type: import("vue").PropType<import("../tree/interface").FilterTreeNode>;
            };
            searchValue: {
                type: StringConstructor;
                default: string;
            };
            virtualListProps: {
                type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
            };
            defaultExpandSelected: {
                type: BooleanConstructor;
            };
            defaultExpandChecked: {
                type: BooleanConstructor;
            };
            autoExpandParent: {
                type: BooleanConstructor;
                default: boolean;
            };
            halfCheckedKeys: {
                type: import("vue").PropType<(string | number)[]>;
            };
            onlyCheckLeaf: {
                type: BooleanConstructor;
                default: boolean;
            };
            animation: {
                type: BooleanConstructor;
                default: boolean;
            };
            actionOnNodeClick: {
                type: import("vue").PropType<"expand">;
            };
            disableSelectActionOnly: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onSelect?: ((selectedKeys: (string | number)[], data: {
                selected?: boolean | undefined;
                selectedNodes: import("..").TreeNodeData[];
                node?: import("..").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => any) | undefined;
            onDrop?: ((data: {
                e: DragEvent;
                dragNode: import("..").TreeNodeData;
                dropNode: import("..").TreeNodeData;
                dropPosition: number;
            }) => any) | undefined;
            "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
            "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
            onExpand?: ((expandKeys: (string | number)[], data: {
                expanded?: boolean | undefined;
                expandedNodes: import("..").TreeNodeData[];
                node?: import("..").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => any) | undefined;
            onCheck?: ((checkedKeys: (string | number)[], data: {
                checked?: boolean | undefined;
                checkedNodes: import("..").TreeNodeData[];
                node?: import("..").TreeNodeData | undefined;
                halfCheckedKeys: (string | number)[];
                halfCheckedNodes: import("..").TreeNodeData[];
                e?: Event | undefined;
            }) => any) | undefined;
            onDragStart?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
            onDragOver?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
            onDragLeave?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
            onDragEnd?: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
            "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
            "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
        }>, {
            classNames: import("vue").ComputedRef<(string | {
                [x: string]: boolean | ((node: import("..").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
            })[]>;
            visibleTreeNodeList: import("vue").ComputedRef<import("../tree/interface").Node[]>;
            treeContext: {
                treeProps: {
                    readonly size: "mini" | "small" | "medium" | "large";
                    readonly data: {
                        key?: string | number | undefined;
                        title?: string | undefined;
                        selectable?: boolean | undefined;
                        disabled?: boolean | undefined;
                        disableCheckbox?: boolean | undefined;
                        checkable?: boolean | undefined;
                        draggable?: boolean | undefined;
                        isLeaf?: boolean | undefined;
                        icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        children?: any[] | undefined;
                    }[];
                    readonly multiple: boolean;
                    readonly animation: boolean;
                    readonly draggable: boolean;
                    readonly checkStrictly: boolean;
                    readonly checkable: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    readonly showLine: boolean;
                    readonly selectable: boolean | ((node: import("..").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    readonly blockNode: boolean;
                    readonly defaultExpandAll: boolean;
                    readonly checkedStrategy: "all" | "child" | "parent";
                    readonly searchValue: string;
                    readonly defaultExpandSelected: boolean;
                    readonly defaultExpandChecked: boolean;
                    readonly autoExpandParent: boolean;
                    readonly onlyCheckLeaf: boolean;
                    readonly disableSelectActionOnly: boolean;
                    readonly fieldNames: {
                        key?: string | undefined;
                        title?: string | undefined;
                        disabled?: string | undefined;
                        children?: string | undefined;
                        isLeaf?: string | undefined;
                        disableCheckbox?: string | undefined;
                        checkable?: string | undefined;
                        icon?: string | undefined;
                    } | undefined;
                    readonly virtualListProps: {
                        height?: string | number | undefined;
                        threshold?: number | undefined;
                        isStaticItemHeight?: boolean | undefined;
                        fixedSize?: boolean | undefined;
                        estimatedSize?: number | undefined;
                        buffer?: number | undefined;
                        data?: unknown[] | undefined;
                        itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
                        component?: keyof HTMLElementTagNameMap | undefined;
                    } | undefined;
                    readonly loadMore: ((node: import("..").TreeNodeData) => Promise<void>) | undefined;
                    readonly selectedKeys: (string | number)[] | undefined;
                    readonly defaultSelectedKeys: (string | number)[] | undefined;
                    readonly expandedKeys: (string | number)[] | undefined;
                    readonly defaultExpandedKeys: (string | number)[] | undefined;
                    readonly checkedKeys: (string | number)[] | undefined;
                    readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                    readonly allowDrop: ((options: {
                        dropNode: import("..").TreeNodeData;
                        dropPosition: 0 | 1 | -1;
                    }) => boolean) | undefined;
                    readonly defaultCheckedKeys: (string | number)[] | undefined;
                    readonly halfCheckedKeys: (string | number)[] | undefined;
                    readonly actionOnNodeClick: "expand" | undefined;
                    readonly onSelect: ((selectedKeys: (string | number)[], data: {
                        selected?: boolean | undefined;
                        selectedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onDrop: ((data: {
                        e: DragEvent;
                        dragNode: import("..").TreeNodeData;
                        dropNode: import("..").TreeNodeData;
                        dropPosition: number;
                    }) => any) | undefined;
                    readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
                    readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
                    readonly onExpand: ((expandKeys: (string | number)[], data: {
                        expanded?: boolean | undefined;
                        expandedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onCheck: ((checkedKeys: (string | number)[], data: {
                        checked?: boolean | undefined;
                        checkedNodes: import("..").TreeNodeData[];
                        node?: import("..").TreeNodeData | undefined;
                        halfCheckedKeys: (string | number)[];
                        halfCheckedNodes: import("..").TreeNodeData[];
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onDragStart: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    readonly onDragOver: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    readonly onDragLeave: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    readonly onDragEnd: ((ev: DragEvent, node: import("..").TreeNodeData) => any) | undefined;
                    readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
                    readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
                };
                switcherIcon: import("vue").Slot<any> | undefined;
                loadingIcon: import("vue").Slot<any> | undefined;
                dragIcon: import("vue").Slot<any> | undefined;
                nodeIcon: import("vue").Slot<any> | undefined;
                nodeTitle: import("vue").Slot<any> | undefined;
                nodeExtra: import("vue").Slot<any> | undefined;
                treeData: {
                    key: import("../tree/interface").TreeNodeKey;
                    treeNodeProps: {
                        selectable: boolean;
                        disabled: boolean;
                        disableCheckbox: boolean;
                        checkable: boolean;
                        draggable: boolean;
                        isLeaf: boolean;
                        isTail: boolean;
                        blockNode: boolean;
                        showLine: boolean;
                        level: number;
                        lineless: boolean[];
                        title?: string | undefined;
                        key?: string | number | undefined;
                        icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                    };
                    treeNodeData: {
                        key?: string | number | undefined;
                        title?: string | undefined;
                        selectable?: boolean | undefined;
                        disabled?: boolean | undefined;
                        disableCheckbox?: boolean | undefined;
                        checkable?: boolean | undefined;
                        draggable?: boolean | undefined;
                        isLeaf?: boolean | undefined;
                        icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>) | undefined;
                        children?: any[] | undefined;
                    };
                    parent?: any | undefined;
                    parentKey?: import("../tree/interface").TreeNodeKey | undefined;
                    pathParentKeys: import("../tree/interface").TreeNodeKey[];
                    children?: any[] | undefined;
                    selectable: boolean;
                    disabled: boolean;
                    disableCheckbox: boolean;
                    checkable: boolean;
                    draggable: boolean;
                    isLeaf: boolean;
                    isTail: boolean;
                    blockNode: boolean;
                    showLine: boolean;
                    level: number;
                    lineless: boolean[];
                    title?: string | undefined;
                    icon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>) | undefined;
                    switcherIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>) | undefined;
                    loadingIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>) | undefined;
                    dragIcon?: (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>) | undefined;
                }[];
                flattenTreeData: import("../tree/interface").Node[];
                key2TreeNode: import("../tree/interface").Key2TreeNode;
                checkedKeys: import("../tree/interface").TreeNodeKey[];
                indeterminateKeys: import("../tree/interface").TreeNodeKey[];
                selectedKeys: import("../tree/interface").TreeNodeKey[];
                expandedKeys: import("../tree/interface").TreeNodeKey[];
                loadingKeys: import("../tree/interface").TreeNodeKey[];
                currentExpandKeys: import("../tree/interface").TreeNodeKey[];
                onLoadMore: ((key: import("../tree/interface").TreeNodeKey) => Promise<void>) | undefined;
                filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                onCheck: (checked: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                onSelect: (key: import("../tree/interface").TreeNodeKey, e: Event) => void;
                onExpand: (expanded: boolean, key: import("../tree/interface").TreeNodeKey, e?: Event | undefined) => void;
                onExpandEnd: (key: import("../tree/interface").TreeNodeKey) => void;
                allowDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                onDragStart: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                onDragEnd: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                onDragOver: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                onDragLeave: (key: import("../tree/interface").TreeNodeKey, e: DragEvent) => void;
                onDrop: (key: import("../tree/interface").TreeNodeKey, dropPosition: number, e: DragEvent) => void;
            };
            virtualListRef: import("vue").Ref<any, any>;
            computedSelectedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
            computedExpandedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
            computedCheckedKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
            computedIndeterminateKeys: import("vue").ComputedRef<import("../tree/interface").TreeNodeKey[]>;
            getPublicCheckedKeys: (rawCheckedKeys: import("../tree/interface").TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => import("../tree/interface").TreeNodeKey[];
            getNodes: (keys: import("../tree/interface").TreeNodeKey[]) => (import("..").TreeNodeData | undefined)[];
            internalCheckNodes: (keys: import("../tree/interface").TreeNodeKey[], checked: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
            internalSetCheckedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
            internalSelectNodes: (keys: import("../tree/interface").TreeNodeKey[], selected: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
            internalSetSelectedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
            internalExpandNodes: (keys: import("../tree/interface").TreeNodeKey[], expanded: boolean, targetKey?: import("../tree/interface").TreeNodeKey | undefined) => void;
            internalSetExpandedKeys: (keys: import("../tree/interface").TreeNodeKey[]) => void;
        }, {}, {}, {
            toggleCheck(key: import("../tree/interface").TreeNodeKey, e: Event): void;
            scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
            getSelectedNodes(): (import("..").TreeNodeData | undefined)[];
            getCheckedNodes(options?: {
                checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                includeHalfChecked?: boolean | undefined;
            }): (import("..").TreeNodeData | undefined)[];
            getHalfCheckedNodes(): (import("..").TreeNodeData | undefined)[];
            getExpandedNodes(): (import("..").TreeNodeData | undefined)[];
            checkAll(checked?: boolean): void;
            checkNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
            selectAll(selected?: boolean): void;
            selectNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], selected?: boolean): void;
            expandAll(expanded?: boolean): void;
            expandNode(key: import("../tree/interface").TreeNodeKey | import("../tree/interface").TreeNodeKey[], expanded?: boolean): void;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            select: (selectedKeys: (string | number)[], data: {
                selected?: boolean | undefined;
                selectedNodes: import("..").TreeNodeData[];
                node?: import("..").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => true;
            'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
            check: (checkedKeys: (string | number)[], data: {
                checked?: boolean | undefined;
                checkedNodes: import("..").TreeNodeData[];
                node?: import("..").TreeNodeData | undefined;
                halfCheckedKeys: (string | number)[];
                halfCheckedNodes: import("..").TreeNodeData[];
                e?: Event | undefined;
            }) => true;
            'update:checkedKeys': (checkedKeys: (string | number)[]) => true;
            'update:halfCheckedKeys': (halfCheckedKeys: (string | number)[]) => true;
            expand: (expandKeys: (string | number)[], data: {
                expanded?: boolean | undefined;
                expandedNodes: import("..").TreeNodeData[];
                node?: import("..").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => true;
            'update:expandedKeys': (expandKeys: (string | number)[]) => true;
            dragStart: (ev: DragEvent, node: import("..").TreeNodeData) => true;
            dragEnd: (ev: DragEvent, node: import("..").TreeNodeData) => true;
            dragOver: (ev: DragEvent, node: import("..").TreeNodeData) => true;
            dragLeave: (ev: DragEvent, node: import("..").TreeNodeData) => true;
            drop: (data: {
                e: DragEvent;
                dragNode: import("..").TreeNodeData;
                dropNode: import("..").TreeNodeData;
                dropPosition: number;
            }) => true;
        }, string, {
            size: "mini" | "small" | "medium" | "large";
            data: import("..").TreeNodeData[];
            multiple: boolean;
            animation: boolean;
            draggable: boolean;
            checkStrictly: boolean;
            checkable: boolean | ((node: import("..").TreeNodeData, info: {
                level: number;
                isLeaf: boolean;
            }) => boolean);
            showLine: boolean;
            selectable: boolean | ((node: import("..").TreeNodeData, info: {
                level: number;
                isLeaf: boolean;
            }) => boolean);
            blockNode: boolean;
            defaultExpandAll: boolean;
            checkedStrategy: "all" | "child" | "parent";
            searchValue: string;
            defaultExpandSelected: boolean;
            defaultExpandChecked: boolean;
            autoExpandParent: boolean;
            onlyCheckLeaf: boolean;
            disableSelectActionOnly: boolean;
        }, {}, string, {}, {
            VirtualList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                data: {
                    type: import("vue").PropType<Record<string, any>[]>;
                    default: () => never[];
                };
                threshold: {
                    type: NumberConstructor;
                    default: number;
                };
                itemKey: {
                    type: StringConstructor;
                    default: string;
                };
                fixedSize: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                estimatedSize: {
                    type: NumberConstructor;
                    default: number;
                };
                buffer: {
                    type: NumberConstructor;
                    default: number;
                };
                component: {
                    type: (ObjectConstructor | StringConstructor)[];
                    default: string;
                };
                listAttrs: {
                    type: ObjectConstructor;
                };
                contentAttrs: {
                    type: ObjectConstructor;
                };
                paddingPosition: {
                    type: StringConstructor;
                    default: string;
                };
            }>, {
                prefixCls: string;
                containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                frontPadding: import("vue").ComputedRef<number>;
                currentList: import("vue").ComputedRef<Record<string, any>[]>;
                behindPadding: import("vue").ComputedRef<number>;
                onScroll: (ev: Event) => void;
                setItemSize: (key: string | number, size: number) => void;
                hasItemSize: (key: string | number) => boolean;
                start: import("vue").Ref<number, number>;
                scrollTo: (options: import("../_components/virtual-list-v2/interface").ScrollOptions) => void;
                style: import("vue").ComputedRef<{
                    height: string;
                    overflow: string;
                }>;
                mergedComponent: import("vue").ComputedRef<{
                    container: string;
                    list: string;
                    content: string;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                scroll: (ev: Event) => true;
                reachBottom: (ev: Event) => true;
            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                data: {
                    type: import("vue").PropType<Record<string, any>[]>;
                    default: () => never[];
                };
                threshold: {
                    type: NumberConstructor;
                    default: number;
                };
                itemKey: {
                    type: StringConstructor;
                    default: string;
                };
                fixedSize: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                estimatedSize: {
                    type: NumberConstructor;
                    default: number;
                };
                buffer: {
                    type: NumberConstructor;
                    default: number;
                };
                component: {
                    type: (ObjectConstructor | StringConstructor)[];
                    default: string;
                };
                listAttrs: {
                    type: ObjectConstructor;
                };
                contentAttrs: {
                    type: ObjectConstructor;
                };
                paddingPosition: {
                    type: StringConstructor;
                    default: string;
                };
            }>> & Readonly<{
                onScroll?: ((ev: Event) => any) | undefined;
                onReachBottom?: ((ev: Event) => any) | undefined;
            }>, {
                data: Record<string, any>[];
                height: string | number;
                threshold: number;
                itemKey: string;
                fixedSize: boolean;
                estimatedSize: number;
                buffer: number;
                component: string | Record<string, any>;
                paddingPosition: string;
            }, {}, {
                VirtualListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    hasItemSize: {
                        type: FunctionConstructor;
                        required: true;
                    };
                    setItemSize: {
                        type: FunctionConstructor;
                        required: true;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    hasItemSize: {
                        type: FunctionConstructor;
                        required: true;
                    };
                    setItemSize: {
                        type: FunctionConstructor;
                        required: true;
                    };
                }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            TreeNode: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
                [x: string]: any;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Empty: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            description: StringConstructor;
            imgSrc: StringConstructor;
            inConfigProvider: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
            inConfigProvider: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            description: StringConstructor;
            imgSrc: StringConstructor;
            inConfigProvider: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
            inConfigProvider: boolean;
        }>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        description: StringConstructor;
        imgSrc: StringConstructor;
        inConfigProvider: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        inConfigProvider: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
        install: (app: App<any>, options?: ArcoOptions | undefined) => void;
    };
    Spin: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            size: {
                type: NumberConstructor;
            };
            loading: BooleanConstructor;
            dot: BooleanConstructor;
            tip: StringConstructor;
            hideIcon: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
            loading: boolean;
            dot: boolean;
            hideIcon: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            size: {
                type: NumberConstructor;
            };
            loading: BooleanConstructor;
            dot: BooleanConstructor;
            tip: StringConstructor;
            hideIcon: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
            loading: boolean;
            dot: boolean;
            hideIcon: boolean;
        }>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        size: {
            type: NumberConstructor;
        };
        loading: BooleanConstructor;
        dot: BooleanConstructor;
        tip: StringConstructor;
        hideIcon: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        loading: boolean;
        dot: boolean;
        hideIcon: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
        install: (app: App<any>, options?: ArcoOptions | undefined) => void;
    };
} & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
    install: (app: App, options?: ArcoOptions | undefined) => void;
};
export declare type TreeSelectInstance = InstanceType<typeof _TreeSelect>;
export default TreeSelect;