import { PropType } from 'vue';
import { TreeProps, TreeNodeKey } from '../tree/interface';
import { ScrollbarProps } from '../scrollbar';
declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    treeProps: {
        type: PropType<Partial<TreeProps>>;
        default: () => {};
    };
    selectedKeys: {
        type: PropType<TreeNodeKey[]>;
    };
    showCheckable: {
        type: BooleanConstructor;
    };
    treeSlots: {
        type: PropType<Readonly<{
            [name: string]: import("vue").Slot<any> | undefined;
        }>>;
        default: () => {};
    };
    scrollbar: {
        type: PropType<boolean | 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: PropType<Partial<TreeProps>>;
        default: () => {};
    };
    selectedKeys: {
        type: PropType<TreeNodeKey[]>;
    };
    showCheckable: {
        type: BooleanConstructor;
    };
    treeSlots: {
        type: PropType<Readonly<{
            [name: string]: import("vue").Slot<any> | undefined;
        }>>;
        default: () => {};
    };
    scrollbar: {
        type: PropType<boolean | ScrollbarProps>;
        default: boolean;
    };
}>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
}>, {
    scrollbar: boolean | ScrollbarProps;
    treeProps: Partial<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: PropType<"mini" | "small" | "medium" | "large">;
                default: string;
            };
            blockNode: {
                type: BooleanConstructor;
            };
            defaultExpandAll: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
            };
            checkable: {
                type: PropType<boolean | ((node: import("../tree").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean)>;
                default: boolean;
            };
            selectable: {
                type: PropType<boolean | ((node: import("../tree").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean)>;
                default: boolean;
            };
            checkStrictly: {
                type: BooleanConstructor;
            };
            checkedStrategy: {
                type: PropType<"all" | "child" | "parent">;
                default: string;
            };
            defaultSelectedKeys: {
                type: PropType<(string | number)[]>;
            };
            selectedKeys: {
                type: PropType<(string | number)[]>;
            };
            defaultCheckedKeys: {
                type: PropType<(string | number)[]>;
            };
            checkedKeys: {
                type: PropType<(string | number)[]>;
            };
            defaultExpandedKeys: {
                type: PropType<(string | number)[]>;
            };
            expandedKeys: {
                type: PropType<(string | number)[]>;
            };
            data: {
                type: PropType<import("../tree").TreeNodeData[]>;
                default: () => never[];
            };
            fieldNames: {
                type: PropType<import("../tree").TreeFieldNames>;
            };
            showLine: {
                type: BooleanConstructor;
            };
            loadMore: {
                type: PropType<(node: import("../tree").TreeNodeData) => Promise<void>>;
            };
            draggable: {
                type: BooleanConstructor;
            };
            allowDrop: {
                type: PropType<(options: {
                    dropNode: import("../tree").TreeNodeData;
                    dropPosition: 0 | 1 | -1;
                }) => boolean>;
            };
            filterTreeNode: {
                type: PropType<import("../tree/interface").FilterTreeNode>;
            };
            searchValue: {
                type: StringConstructor;
                default: string;
            };
            virtualListProps: {
                type: PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
            };
            defaultExpandSelected: {
                type: BooleanConstructor;
            };
            defaultExpandChecked: {
                type: BooleanConstructor;
            };
            autoExpandParent: {
                type: BooleanConstructor;
                default: boolean;
            };
            halfCheckedKeys: {
                type: PropType<(string | number)[]>;
            };
            onlyCheckLeaf: {
                type: BooleanConstructor;
                default: boolean;
            };
            animation: {
                type: BooleanConstructor;
                default: boolean;
            };
            actionOnNodeClick: {
                type: PropType<"expand">;
            };
            disableSelectActionOnly: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onSelect?: ((selectedKeys: (string | number)[], data: {
                selected?: boolean | undefined;
                selectedNodes: import("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => any) | undefined;
            onDrop?: ((data: {
                e: DragEvent;
                dragNode: import("../tree").TreeNodeData;
                dropNode: import("../tree").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("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => any) | undefined;
            onCheck?: ((checkedKeys: (string | number)[], data: {
                checked?: boolean | undefined;
                checkedNodes: import("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                halfCheckedKeys: (string | number)[];
                halfCheckedNodes: import("../tree").TreeNodeData[];
                e?: Event | undefined;
            }) => any) | undefined;
            onDragStart?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
            onDragOver?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
            onDragLeave?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
            onDragEnd?: ((ev: DragEvent, node: import("../tree").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("../tree").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("../tree").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    readonly showLine: boolean;
                    readonly selectable: boolean | ((node: import("../tree").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("../tree").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("../tree").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("../tree").TreeNodeData[];
                        node?: import("../tree").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onDrop: ((data: {
                        e: DragEvent;
                        dragNode: import("../tree").TreeNodeData;
                        dropNode: import("../tree").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("../tree").TreeNodeData[];
                        node?: import("../tree").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onCheck: ((checkedKeys: (string | number)[], data: {
                        checked?: boolean | undefined;
                        checkedNodes: import("../tree").TreeNodeData[];
                        node?: import("../tree").TreeNodeData | undefined;
                        halfCheckedKeys: (string | number)[];
                        halfCheckedNodes: import("../tree").TreeNodeData[];
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onDragStart: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                    readonly onDragOver: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                    readonly onDragLeave: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                    readonly onDragEnd: ((ev: DragEvent, node: import("../tree").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: 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?: TreeNodeKey | undefined;
                    pathParentKeys: 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: TreeNodeKey[];
                indeterminateKeys: TreeNodeKey[];
                selectedKeys: TreeNodeKey[];
                expandedKeys: TreeNodeKey[];
                loadingKeys: TreeNodeKey[];
                currentExpandKeys: TreeNodeKey[];
                onLoadMore: ((key: TreeNodeKey) => Promise<void>) | undefined;
                filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                onCheck: (checked: boolean, key: TreeNodeKey, e?: Event | undefined) => void;
                onSelect: (key: TreeNodeKey, e: Event) => void;
                onExpand: (expanded: boolean, key: TreeNodeKey, e?: Event | undefined) => void;
                onExpandEnd: (key: TreeNodeKey) => void;
                allowDrop: (key: TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                onDragStart: (key: TreeNodeKey, e: DragEvent) => void;
                onDragEnd: (key: TreeNodeKey, e: DragEvent) => void;
                onDragOver: (key: TreeNodeKey, e: DragEvent) => void;
                onDragLeave: (key: TreeNodeKey, e: DragEvent) => void;
                onDrop: (key: TreeNodeKey, dropPosition: number, e: DragEvent) => void;
            };
            virtualListRef: import("vue").Ref<any, any>;
            computedSelectedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            computedExpandedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            computedCheckedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            computedIndeterminateKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            getPublicCheckedKeys: (rawCheckedKeys: TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => TreeNodeKey[];
            getNodes: (keys: TreeNodeKey[]) => (import("../tree").TreeNodeData | undefined)[];
            internalCheckNodes: (keys: TreeNodeKey[], checked: boolean, targetKey?: TreeNodeKey | undefined) => void;
            internalSetCheckedKeys: (keys: TreeNodeKey[]) => void;
            internalSelectNodes: (keys: TreeNodeKey[], selected: boolean, targetKey?: TreeNodeKey | undefined) => void;
            internalSetSelectedKeys: (keys: TreeNodeKey[]) => void;
            internalExpandNodes: (keys: TreeNodeKey[], expanded: boolean, targetKey?: TreeNodeKey | undefined) => void;
            internalSetExpandedKeys: (keys: TreeNodeKey[]) => void;
        }, {}, {}, {
            toggleCheck(key: TreeNodeKey, e: Event): void;
            scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
            getSelectedNodes(): (import("../tree").TreeNodeData | undefined)[];
            getCheckedNodes(options?: {
                checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                includeHalfChecked?: boolean | undefined;
            }): (import("../tree").TreeNodeData | undefined)[];
            getHalfCheckedNodes(): (import("../tree").TreeNodeData | undefined)[];
            getExpandedNodes(): (import("../tree").TreeNodeData | undefined)[];
            checkAll(checked?: boolean): void;
            checkNode(key: TreeNodeKey | TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
            selectAll(selected?: boolean): void;
            selectNode(key: TreeNodeKey | TreeNodeKey[], selected?: boolean): void;
            expandAll(expanded?: boolean): void;
            expandNode(key: TreeNodeKey | TreeNodeKey[], expanded?: boolean): void;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            select: (selectedKeys: (string | number)[], data: {
                selected?: boolean | undefined;
                selectedNodes: import("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => true;
            'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
            check: (checkedKeys: (string | number)[], data: {
                checked?: boolean | undefined;
                checkedNodes: import("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                halfCheckedKeys: (string | number)[];
                halfCheckedNodes: import("../tree").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("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => true;
            'update:expandedKeys': (expandKeys: (string | number)[]) => true;
            dragStart: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
            dragEnd: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
            dragOver: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
            dragLeave: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
            drop: (data: {
                e: DragEvent;
                dragNode: import("../tree").TreeNodeData;
                dropNode: import("../tree").TreeNodeData;
                dropPosition: number;
            }) => true;
        }, import("vue").PublicProps, {
            size: "mini" | "small" | "medium" | "large";
            data: import("../tree").TreeNodeData[];
            multiple: boolean;
            animation: boolean;
            draggable: boolean;
            checkStrictly: boolean;
            checkable: boolean | ((node: import("../tree").TreeNodeData, info: {
                level: number;
                isLeaf: boolean;
            }) => boolean);
            showLine: boolean;
            selectable: boolean | ((node: import("../tree").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: 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: 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: PropType<"mini" | "small" | "medium" | "large">;
                default: string;
            };
            blockNode: {
                type: BooleanConstructor;
            };
            defaultExpandAll: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
            };
            checkable: {
                type: PropType<boolean | ((node: import("../tree").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean)>;
                default: boolean;
            };
            selectable: {
                type: PropType<boolean | ((node: import("../tree").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean)>;
                default: boolean;
            };
            checkStrictly: {
                type: BooleanConstructor;
            };
            checkedStrategy: {
                type: PropType<"all" | "child" | "parent">;
                default: string;
            };
            defaultSelectedKeys: {
                type: PropType<(string | number)[]>;
            };
            selectedKeys: {
                type: PropType<(string | number)[]>;
            };
            defaultCheckedKeys: {
                type: PropType<(string | number)[]>;
            };
            checkedKeys: {
                type: PropType<(string | number)[]>;
            };
            defaultExpandedKeys: {
                type: PropType<(string | number)[]>;
            };
            expandedKeys: {
                type: PropType<(string | number)[]>;
            };
            data: {
                type: PropType<import("../tree").TreeNodeData[]>;
                default: () => never[];
            };
            fieldNames: {
                type: PropType<import("../tree").TreeFieldNames>;
            };
            showLine: {
                type: BooleanConstructor;
            };
            loadMore: {
                type: PropType<(node: import("../tree").TreeNodeData) => Promise<void>>;
            };
            draggable: {
                type: BooleanConstructor;
            };
            allowDrop: {
                type: PropType<(options: {
                    dropNode: import("../tree").TreeNodeData;
                    dropPosition: 0 | 1 | -1;
                }) => boolean>;
            };
            filterTreeNode: {
                type: PropType<import("../tree/interface").FilterTreeNode>;
            };
            searchValue: {
                type: StringConstructor;
                default: string;
            };
            virtualListProps: {
                type: PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
            };
            defaultExpandSelected: {
                type: BooleanConstructor;
            };
            defaultExpandChecked: {
                type: BooleanConstructor;
            };
            autoExpandParent: {
                type: BooleanConstructor;
                default: boolean;
            };
            halfCheckedKeys: {
                type: PropType<(string | number)[]>;
            };
            onlyCheckLeaf: {
                type: BooleanConstructor;
                default: boolean;
            };
            animation: {
                type: BooleanConstructor;
                default: boolean;
            };
            actionOnNodeClick: {
                type: PropType<"expand">;
            };
            disableSelectActionOnly: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onSelect?: ((selectedKeys: (string | number)[], data: {
                selected?: boolean | undefined;
                selectedNodes: import("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => any) | undefined;
            onDrop?: ((data: {
                e: DragEvent;
                dragNode: import("../tree").TreeNodeData;
                dropNode: import("../tree").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("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                e?: Event | undefined;
            }) => any) | undefined;
            onCheck?: ((checkedKeys: (string | number)[], data: {
                checked?: boolean | undefined;
                checkedNodes: import("../tree").TreeNodeData[];
                node?: import("../tree").TreeNodeData | undefined;
                halfCheckedKeys: (string | number)[];
                halfCheckedNodes: import("../tree").TreeNodeData[];
                e?: Event | undefined;
            }) => any) | undefined;
            onDragStart?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
            onDragOver?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
            onDragLeave?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
            onDragEnd?: ((ev: DragEvent, node: import("../tree").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("../tree").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("../tree").TreeNodeData, info: {
                        level: number;
                        isLeaf: boolean;
                    }) => boolean);
                    readonly showLine: boolean;
                    readonly selectable: boolean | ((node: import("../tree").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("../tree").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("../tree").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("../tree").TreeNodeData[];
                        node?: import("../tree").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onDrop: ((data: {
                        e: DragEvent;
                        dragNode: import("../tree").TreeNodeData;
                        dropNode: import("../tree").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("../tree").TreeNodeData[];
                        node?: import("../tree").TreeNodeData | undefined;
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onCheck: ((checkedKeys: (string | number)[], data: {
                        checked?: boolean | undefined;
                        checkedNodes: import("../tree").TreeNodeData[];
                        node?: import("../tree").TreeNodeData | undefined;
                        halfCheckedKeys: (string | number)[];
                        halfCheckedNodes: import("../tree").TreeNodeData[];
                        e?: Event | undefined;
                    }) => any) | undefined;
                    readonly onDragStart: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                    readonly onDragOver: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                    readonly onDragLeave: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                    readonly onDragEnd: ((ev: DragEvent, node: import("../tree").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: 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?: TreeNodeKey | undefined;
                    pathParentKeys: 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: TreeNodeKey[];
                indeterminateKeys: TreeNodeKey[];
                selectedKeys: TreeNodeKey[];
                expandedKeys: TreeNodeKey[];
                loadingKeys: TreeNodeKey[];
                currentExpandKeys: TreeNodeKey[];
                onLoadMore: ((key: TreeNodeKey) => Promise<void>) | undefined;
                filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
                onCheck: (checked: boolean, key: TreeNodeKey, e?: Event | undefined) => void;
                onSelect: (key: TreeNodeKey, e: Event) => void;
                onExpand: (expanded: boolean, key: TreeNodeKey, e?: Event | undefined) => void;
                onExpandEnd: (key: TreeNodeKey) => void;
                allowDrop: (key: TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
                onDragStart: (key: TreeNodeKey, e: DragEvent) => void;
                onDragEnd: (key: TreeNodeKey, e: DragEvent) => void;
                onDragOver: (key: TreeNodeKey, e: DragEvent) => void;
                onDragLeave: (key: TreeNodeKey, e: DragEvent) => void;
                onDrop: (key: TreeNodeKey, dropPosition: number, e: DragEvent) => void;
            };
            virtualListRef: import("vue").Ref<any, any>;
            computedSelectedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            computedExpandedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            computedCheckedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            computedIndeterminateKeys: import("vue").ComputedRef<TreeNodeKey[]>;
            getPublicCheckedKeys: (rawCheckedKeys: TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => TreeNodeKey[];
            getNodes: (keys: TreeNodeKey[]) => (import("../tree").TreeNodeData | undefined)[];
            internalCheckNodes: (keys: TreeNodeKey[], checked: boolean, targetKey?: TreeNodeKey | undefined) => void;
            internalSetCheckedKeys: (keys: TreeNodeKey[]) => void;
            internalSelectNodes: (keys: TreeNodeKey[], selected: boolean, targetKey?: TreeNodeKey | undefined) => void;
            internalSetSelectedKeys: (keys: TreeNodeKey[]) => void;
            internalExpandNodes: (keys: TreeNodeKey[], expanded: boolean, targetKey?: TreeNodeKey | undefined) => void;
            internalSetExpandedKeys: (keys: TreeNodeKey[]) => void;
        }, {}, {}, {
            toggleCheck(key: TreeNodeKey, e: Event): void;
            scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
            getSelectedNodes(): (import("../tree").TreeNodeData | undefined)[];
            getCheckedNodes(options?: {
                checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
                includeHalfChecked?: boolean | undefined;
            }): (import("../tree").TreeNodeData | undefined)[];
            getHalfCheckedNodes(): (import("../tree").TreeNodeData | undefined)[];
            getExpandedNodes(): (import("../tree").TreeNodeData | undefined)[];
            checkAll(checked?: boolean): void;
            checkNode(key: TreeNodeKey | TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
            selectAll(selected?: boolean): void;
            selectNode(key: TreeNodeKey | TreeNodeKey[], selected?: boolean): void;
            expandAll(expanded?: boolean): void;
            expandNode(key: TreeNodeKey | TreeNodeKey[], expanded?: boolean): void;
        }, {
            size: "mini" | "small" | "medium" | "large";
            data: import("../tree").TreeNodeData[];
            multiple: boolean;
            animation: boolean;
            draggable: boolean;
            checkStrictly: boolean;
            checkable: boolean | ((node: import("../tree").TreeNodeData, info: {
                level: number;
                isLeaf: boolean;
            }) => boolean);
            showLine: boolean;
            selectable: boolean | ((node: import("../tree").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: PropType<"mini" | "small" | "medium" | "large">;
            default: string;
        };
        blockNode: {
            type: BooleanConstructor;
        };
        defaultExpandAll: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
        };
        checkable: {
            type: PropType<boolean | ((node: import("../tree").TreeNodeData, info: {
                level: number;
                isLeaf: boolean;
            }) => boolean)>;
            default: boolean;
        };
        selectable: {
            type: PropType<boolean | ((node: import("../tree").TreeNodeData, info: {
                level: number;
                isLeaf: boolean;
            }) => boolean)>;
            default: boolean;
        };
        checkStrictly: {
            type: BooleanConstructor;
        };
        checkedStrategy: {
            type: PropType<"all" | "child" | "parent">;
            default: string;
        };
        defaultSelectedKeys: {
            type: PropType<(string | number)[]>;
        };
        selectedKeys: {
            type: PropType<(string | number)[]>;
        };
        defaultCheckedKeys: {
            type: PropType<(string | number)[]>;
        };
        checkedKeys: {
            type: PropType<(string | number)[]>;
        };
        defaultExpandedKeys: {
            type: PropType<(string | number)[]>;
        };
        expandedKeys: {
            type: PropType<(string | number)[]>;
        };
        data: {
            type: PropType<import("../tree").TreeNodeData[]>;
            default: () => never[];
        };
        fieldNames: {
            type: PropType<import("../tree").TreeFieldNames>;
        };
        showLine: {
            type: BooleanConstructor;
        };
        loadMore: {
            type: PropType<(node: import("../tree").TreeNodeData) => Promise<void>>;
        };
        draggable: {
            type: BooleanConstructor;
        };
        allowDrop: {
            type: PropType<(options: {
                dropNode: import("../tree").TreeNodeData;
                dropPosition: 0 | 1 | -1;
            }) => boolean>;
        };
        filterTreeNode: {
            type: PropType<import("../tree/interface").FilterTreeNode>;
        };
        searchValue: {
            type: StringConstructor;
            default: string;
        };
        virtualListProps: {
            type: PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
        };
        defaultExpandSelected: {
            type: BooleanConstructor;
        };
        defaultExpandChecked: {
            type: BooleanConstructor;
        };
        autoExpandParent: {
            type: BooleanConstructor;
            default: boolean;
        };
        halfCheckedKeys: {
            type: PropType<(string | number)[]>;
        };
        onlyCheckLeaf: {
            type: BooleanConstructor;
            default: boolean;
        };
        animation: {
            type: BooleanConstructor;
            default: boolean;
        };
        actionOnNodeClick: {
            type: PropType<"expand">;
        };
        disableSelectActionOnly: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onSelect?: ((selectedKeys: (string | number)[], data: {
            selected?: boolean | undefined;
            selectedNodes: import("../tree").TreeNodeData[];
            node?: import("../tree").TreeNodeData | undefined;
            e?: Event | undefined;
        }) => any) | undefined;
        onDrop?: ((data: {
            e: DragEvent;
            dragNode: import("../tree").TreeNodeData;
            dropNode: import("../tree").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("../tree").TreeNodeData[];
            node?: import("../tree").TreeNodeData | undefined;
            e?: Event | undefined;
        }) => any) | undefined;
        onCheck?: ((checkedKeys: (string | number)[], data: {
            checked?: boolean | undefined;
            checkedNodes: import("../tree").TreeNodeData[];
            node?: import("../tree").TreeNodeData | undefined;
            halfCheckedKeys: (string | number)[];
            halfCheckedNodes: import("../tree").TreeNodeData[];
            e?: Event | undefined;
        }) => any) | undefined;
        onDragStart?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
        onDragOver?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
        onDragLeave?: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
        onDragEnd?: ((ev: DragEvent, node: import("../tree").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("../tree").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("../tree").TreeNodeData, info: {
                    level: number;
                    isLeaf: boolean;
                }) => boolean);
                readonly showLine: boolean;
                readonly selectable: boolean | ((node: import("../tree").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("../tree").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("../tree").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("../tree").TreeNodeData[];
                    node?: import("../tree").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                readonly onDrop: ((data: {
                    e: DragEvent;
                    dragNode: import("../tree").TreeNodeData;
                    dropNode: import("../tree").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("../tree").TreeNodeData[];
                    node?: import("../tree").TreeNodeData | undefined;
                    e?: Event | undefined;
                }) => any) | undefined;
                readonly onCheck: ((checkedKeys: (string | number)[], data: {
                    checked?: boolean | undefined;
                    checkedNodes: import("../tree").TreeNodeData[];
                    node?: import("../tree").TreeNodeData | undefined;
                    halfCheckedKeys: (string | number)[];
                    halfCheckedNodes: import("../tree").TreeNodeData[];
                    e?: Event | undefined;
                }) => any) | undefined;
                readonly onDragStart: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                readonly onDragOver: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                readonly onDragLeave: ((ev: DragEvent, node: import("../tree").TreeNodeData) => any) | undefined;
                readonly onDragEnd: ((ev: DragEvent, node: import("../tree").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: 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?: TreeNodeKey | undefined;
                pathParentKeys: 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: TreeNodeKey[];
            indeterminateKeys: TreeNodeKey[];
            selectedKeys: TreeNodeKey[];
            expandedKeys: TreeNodeKey[];
            loadingKeys: TreeNodeKey[];
            currentExpandKeys: TreeNodeKey[];
            onLoadMore: ((key: TreeNodeKey) => Promise<void>) | undefined;
            filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
            onCheck: (checked: boolean, key: TreeNodeKey, e?: Event | undefined) => void;
            onSelect: (key: TreeNodeKey, e: Event) => void;
            onExpand: (expanded: boolean, key: TreeNodeKey, e?: Event | undefined) => void;
            onExpandEnd: (key: TreeNodeKey) => void;
            allowDrop: (key: TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
            onDragStart: (key: TreeNodeKey, e: DragEvent) => void;
            onDragEnd: (key: TreeNodeKey, e: DragEvent) => void;
            onDragOver: (key: TreeNodeKey, e: DragEvent) => void;
            onDragLeave: (key: TreeNodeKey, e: DragEvent) => void;
            onDrop: (key: TreeNodeKey, dropPosition: number, e: DragEvent) => void;
        };
        virtualListRef: import("vue").Ref<any, any>;
        computedSelectedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
        computedExpandedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
        computedCheckedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
        computedIndeterminateKeys: import("vue").ComputedRef<TreeNodeKey[]>;
        getPublicCheckedKeys: (rawCheckedKeys: TreeNodeKey[], rawCheckedStrategy?: "all" | "child" | "parent") => TreeNodeKey[];
        getNodes: (keys: TreeNodeKey[]) => (import("../tree").TreeNodeData | undefined)[];
        internalCheckNodes: (keys: TreeNodeKey[], checked: boolean, targetKey?: TreeNodeKey | undefined) => void;
        internalSetCheckedKeys: (keys: TreeNodeKey[]) => void;
        internalSelectNodes: (keys: TreeNodeKey[], selected: boolean, targetKey?: TreeNodeKey | undefined) => void;
        internalSetSelectedKeys: (keys: TreeNodeKey[]) => void;
        internalExpandNodes: (keys: TreeNodeKey[], expanded: boolean, targetKey?: TreeNodeKey | undefined) => void;
        internalSetExpandedKeys: (keys: TreeNodeKey[]) => void;
    }, {}, {}, {
        toggleCheck(key: TreeNodeKey, e: Event): void;
        scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
        getSelectedNodes(): (import("../tree").TreeNodeData | undefined)[];
        getCheckedNodes(options?: {
            checkedStrategy?: import("../tree/interface").CheckedStrategy | undefined;
            includeHalfChecked?: boolean | undefined;
        }): (import("../tree").TreeNodeData | undefined)[];
        getHalfCheckedNodes(): (import("../tree").TreeNodeData | undefined)[];
        getExpandedNodes(): (import("../tree").TreeNodeData | undefined)[];
        checkAll(checked?: boolean): void;
        checkNode(key: TreeNodeKey | TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
        selectAll(selected?: boolean): void;
        selectNode(key: TreeNodeKey | TreeNodeKey[], selected?: boolean): void;
        expandAll(expanded?: boolean): void;
        expandNode(key: TreeNodeKey | TreeNodeKey[], expanded?: boolean): void;
    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        select: (selectedKeys: (string | number)[], data: {
            selected?: boolean | undefined;
            selectedNodes: import("../tree").TreeNodeData[];
            node?: import("../tree").TreeNodeData | undefined;
            e?: Event | undefined;
        }) => true;
        'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
        check: (checkedKeys: (string | number)[], data: {
            checked?: boolean | undefined;
            checkedNodes: import("../tree").TreeNodeData[];
            node?: import("../tree").TreeNodeData | undefined;
            halfCheckedKeys: (string | number)[];
            halfCheckedNodes: import("../tree").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("../tree").TreeNodeData[];
            node?: import("../tree").TreeNodeData | undefined;
            e?: Event | undefined;
        }) => true;
        'update:expandedKeys': (expandKeys: (string | number)[]) => true;
        dragStart: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
        dragEnd: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
        dragOver: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
        dragLeave: (ev: DragEvent, node: import("../tree").TreeNodeData) => true;
        drop: (data: {
            e: DragEvent;
            dragNode: import("../tree").TreeNodeData;
            dropNode: import("../tree").TreeNodeData;
            dropPosition: number;
        }) => true;
    }, string, {
        size: "mini" | "small" | "medium" | "large";
        data: import("../tree").TreeNodeData[];
        multiple: boolean;
        animation: boolean;
        draggable: boolean;
        checkStrictly: boolean;
        checkable: boolean | ((node: import("../tree").TreeNodeData, info: {
            level: number;
            isLeaf: boolean;
        }) => boolean);
        showLine: boolean;
        selectable: boolean | ((node: import("../tree").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: 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: 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: import("vue").App<any>, options?: import("../_utils/types").ArcoOptions | undefined) => void;
    };
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _default;