ep-craft 0.1.34 → 0.1.36

package/dist/components/tree/src/tree.vue.d.ts

@@ -0,0 +1,1745 @@
+import TreeStore from './model/tree-store';
+import type Node from './model/node';
+import type { ComponentInternalInstance } from 'vue';
+import type { Nullable } from '@element-plus/utils';
+import type { FilterValue, TreeData, TreeKey, TreeNodeData } from './tree.type';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly emptyText: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly renderAfterExpand: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly nodeKey: StringConstructor;
+    readonly checkStrictly: BooleanConstructor;
+    readonly defaultExpandAll: BooleanConstructor;
+    readonly expandOnClickNode: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly checkOnClickNode: BooleanConstructor;
+    readonly checkOnClickLeaf: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly checkDescendants: BooleanConstructor;
+    readonly autoExpandParent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly defaultCheckedKeys: {
+        readonly type: import("vue").PropType<TreeKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultExpandedKeys: {
+        readonly type: import("vue").PropType<TreeKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly currentNodeKey: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly renderContent: {
+        readonly type: import("vue").PropType<import("./tree.type").RenderContentFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly showCheckbox: BooleanConstructor;
+    readonly draggable: BooleanConstructor;
+    readonly allowDrag: {
+        readonly type: import("vue").PropType<import("./tree.type").AllowDragFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly allowDrop: {
+        readonly type: import("vue").PropType<import("./tree.type").AllowDropFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("./tree.type").TreeOptionProps) | (() => import("./tree.type").TreeOptionProps) | (((new (...args: any[]) => import("./tree.type").TreeOptionProps) | (() => import("./tree.type").TreeOptionProps)) | null)[], unknown, unknown, () => {
+        children: string;
+        label: string;
+        disabled: string;
+    }, boolean>;
+    readonly lazy: BooleanConstructor;
+    readonly highlightCurrent: BooleanConstructor;
+    readonly load: {
+        readonly type: import("vue").PropType<import("./tree.type").LoadFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly filterNodeMethod: {
+        readonly type: import("vue").PropType<import("./tree.type").FilterNodeMethodFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly accordion: BooleanConstructor;
+    readonly indent: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    store: import("vue").Ref<{
+        currentNode: {
+            id: number;
+            text: string | null;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: /*elided*/ any | null;
+            visible: boolean;
+            isCurrent: boolean;
+            store: /*elided*/ any;
+            isLeafByUser: boolean | undefined;
+            isLeaf: boolean | undefined;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: /*elided*/ any[];
+            loading: boolean;
+            isEffectivelyChecked: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: TreeKey | null | undefined;
+            readonly disabled: boolean;
+            readonly nextSibling: /*elided*/ any | null;
+            readonly previousSibling: /*elided*/ any | null;
+            contains: (target: Node, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            removeChild: (child: Node) => void;
+            removeChildByData: (data: TreeNodeData | null) => void;
+            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: Node) => void) => void;
+            reInitChecked: () => void;
+        } | null;
+        currentNodeKey: TreeKey | null;
+        nodesMap: import("./tree.type").TreeStoreNodesMap;
+        root: {
+            id: number;
+            text: string | null;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: /*elided*/ any | null;
+            visible: boolean;
+            isCurrent: boolean;
+            store: /*elided*/ any;
+            isLeafByUser: boolean | undefined;
+            isLeaf: boolean | undefined;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: /*elided*/ any[];
+            loading: boolean;
+            isEffectivelyChecked: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: TreeKey | null | undefined;
+            readonly disabled: boolean;
+            readonly nextSibling: /*elided*/ any | null;
+            readonly previousSibling: /*elided*/ any | null;
+            contains: (target: Node, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            removeChild: (child: Node) => void;
+            removeChildByData: (data: TreeNodeData | null) => void;
+            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: Node) => void) => void;
+            reInitChecked: () => void;
+        };
+        data: TreeNodeData[];
+        lazy: boolean;
+        load?: import("./tree.type").LoadFunction | undefined;
+        filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+        key: TreeKey;
+        defaultCheckedKeys?: TreeKey[] | undefined;
+        checkStrictly: boolean;
+        defaultExpandedKeys?: TreeKey[] | undefined;
+        autoExpandParent: boolean;
+        defaultExpandAll: boolean;
+        checkDescendants: boolean;
+        props: {
+            children?: string | undefined;
+            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            class?: ((data: TreeNodeData, node: Node) => string | {
+                [key: string]: boolean;
+            }) | undefined;
+        };
+        initialize: () => void;
+        filter: (value: FilterValue) => void;
+        setData: (newVal: TreeData) => void;
+        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+        remove: (data: TreeNodeData | Node) => void;
+        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+        _initDefaultCheckedNodes: () => void;
+        _initDefaultCheckedNode: (node: Node) => void;
+        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+        registerNode: (node: Node) => void;
+        deregisterNode: (node: Node) => void;
+        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+        getHalfCheckedNodes: () => TreeNodeData[];
+        getHalfCheckedKeys: () => TreeKey[];
+        _getAllNodes: () => Node[];
+        updateChildren: (key: TreeKey, data: TreeData) => void;
+        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+            [key: string]: boolean;
+        }) => void;
+        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+        getCurrentNode: () => Node | null;
+        setCurrentNode: (currentNode: Node) => void;
+        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+    }, TreeStore | {
+        currentNode: {
+            id: number;
+            text: string | null;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: /*elided*/ any | null;
+            visible: boolean;
+            isCurrent: boolean;
+            store: /*elided*/ any;
+            isLeafByUser: boolean | undefined;
+            isLeaf: boolean | undefined;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: /*elided*/ any[];
+            loading: boolean;
+            isEffectivelyChecked: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: TreeKey | null | undefined;
+            readonly disabled: boolean;
+            readonly nextSibling: /*elided*/ any | null;
+            readonly previousSibling: /*elided*/ any | null;
+            contains: (target: Node, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            removeChild: (child: Node) => void;
+            removeChildByData: (data: TreeNodeData | null) => void;
+            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: Node) => void) => void;
+            reInitChecked: () => void;
+        } | null;
+        currentNodeKey: TreeKey | null;
+        nodesMap: import("./tree.type").TreeStoreNodesMap;
+        root: {
+            id: number;
+            text: string | null;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: /*elided*/ any | null;
+            visible: boolean;
+            isCurrent: boolean;
+            store: /*elided*/ any;
+            isLeafByUser: boolean | undefined;
+            isLeaf: boolean | undefined;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: /*elided*/ any[];
+            loading: boolean;
+            isEffectivelyChecked: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: TreeKey | null | undefined;
+            readonly disabled: boolean;
+            readonly nextSibling: /*elided*/ any | null;
+            readonly previousSibling: /*elided*/ any | null;
+            contains: (target: Node, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+            removeChild: (child: Node) => void;
+            removeChildByData: (data: TreeNodeData | null) => void;
+            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: Node) => void) => void;
+            reInitChecked: () => void;
+        };
+        data: TreeNodeData[];
+        lazy: boolean;
+        load?: import("./tree.type").LoadFunction | undefined;
+        filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+        key: TreeKey;
+        defaultCheckedKeys?: TreeKey[] | undefined;
+        checkStrictly: boolean;
+        defaultExpandedKeys?: TreeKey[] | undefined;
+        autoExpandParent: boolean;
+        defaultExpandAll: boolean;
+        checkDescendants: boolean;
+        props: {
+            children?: string | undefined;
+            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            class?: ((data: TreeNodeData, node: Node) => string | {
+                [key: string]: boolean;
+            }) | undefined;
+        };
+        initialize: () => void;
+        filter: (value: FilterValue) => void;
+        setData: (newVal: TreeData) => void;
+        getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+        remove: (data: TreeNodeData | Node) => void;
+        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+        _initDefaultCheckedNodes: () => void;
+        _initDefaultCheckedNode: (node: Node) => void;
+        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+        registerNode: (node: Node) => void;
+        deregisterNode: (node: Node) => void;
+        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+        getHalfCheckedNodes: () => TreeNodeData[];
+        getHalfCheckedKeys: () => TreeKey[];
+        _getAllNodes: () => Node[];
+        updateChildren: (key: TreeKey, data: TreeData) => void;
+        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+            [key: string]: boolean;
+        }) => void;
+        setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+        getCurrentNode: () => Node | null;
+        setCurrentNode: (currentNode: Node) => void;
+        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+    }>;
+    root: import("vue").Ref<{
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/ any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+            currentNode: /*elided*/ any | null;
+            currentNodeKey: TreeKey | null;
+            nodesMap: import("./tree.type").TreeStoreNodesMap;
+            root: /*elided*/ any;
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("./tree.type").LoadFunction | undefined;
+            filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+            key: TreeKey;
+            defaultCheckedKeys?: TreeKey[] | undefined;
+            checkStrictly: boolean;
+            defaultExpandedKeys?: TreeKey[] | undefined;
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string | undefined;
+                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                class?: ((data: TreeNodeData, node: Node) => string | {
+                    [key: string]: boolean;
+                }) | undefined;
+            };
+            initialize: () => void;
+            filter: (value: FilterValue) => void;
+            setData: (newVal: TreeData) => void;
+            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            remove: (data: TreeNodeData | Node) => void;
+            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: Node) => void;
+            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+            registerNode: (node: Node) => void;
+            deregisterNode: (node: Node) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => TreeKey[];
+            _getAllNodes: () => Node[];
+            updateChildren: (key: TreeKey, data: TreeData) => void;
+            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => Node | null;
+            setCurrentNode: (currentNode: Node) => void;
+            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/ any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/ any | null;
+        readonly previousSibling: /*elided*/ any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+        insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData | null) => void;
+        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+        updateChildren: () => void;
+        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        eachNode: (callback: (node: Node) => void) => void;
+        reInitChecked: () => void;
+    }, Node | {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/ any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+            currentNode: /*elided*/ any | null;
+            currentNodeKey: TreeKey | null;
+            nodesMap: import("./tree.type").TreeStoreNodesMap;
+            root: /*elided*/ any;
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("./tree.type").LoadFunction | undefined;
+            filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+            key: TreeKey;
+            defaultCheckedKeys?: TreeKey[] | undefined;
+            checkStrictly: boolean;
+            defaultExpandedKeys?: TreeKey[] | undefined;
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string | undefined;
+                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                class?: ((data: TreeNodeData, node: Node) => string | {
+                    [key: string]: boolean;
+                }) | undefined;
+            };
+            initialize: () => void;
+            filter: (value: FilterValue) => void;
+            setData: (newVal: TreeData) => void;
+            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            remove: (data: TreeNodeData | Node) => void;
+            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: Node) => void;
+            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+            registerNode: (node: Node) => void;
+            deregisterNode: (node: Node) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => TreeKey[];
+            _getAllNodes: () => Node[];
+            updateChildren: (key: TreeKey, data: TreeData) => void;
+            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => Node | null;
+            setCurrentNode: (currentNode: Node) => void;
+            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/ any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/ any | null;
+        readonly previousSibling: /*elided*/ any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+        insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData | null) => void;
+        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+        updateChildren: () => void;
+        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        eachNode: (callback: (node: Node) => void) => void;
+        reInitChecked: () => void;
+    }>;
+    currentNode: import("vue").Ref<{
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/ any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+            currentNode: /*elided*/ any | null;
+            currentNodeKey: TreeKey | null;
+            nodesMap: import("./tree.type").TreeStoreNodesMap;
+            root: /*elided*/ any;
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("./tree.type").LoadFunction | undefined;
+            filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+            key: TreeKey;
+            defaultCheckedKeys?: TreeKey[] | undefined;
+            checkStrictly: boolean;
+            defaultExpandedKeys?: TreeKey[] | undefined;
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string | undefined;
+                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                class?: ((data: TreeNodeData, node: Node) => string | {
+                    [key: string]: boolean;
+                }) | undefined;
+            };
+            initialize: () => void;
+            filter: (value: FilterValue) => void;
+            setData: (newVal: TreeData) => void;
+            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            remove: (data: TreeNodeData | Node) => void;
+            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: Node) => void;
+            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+            registerNode: (node: Node) => void;
+            deregisterNode: (node: Node) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => TreeKey[];
+            _getAllNodes: () => Node[];
+            updateChildren: (key: TreeKey, data: TreeData) => void;
+            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => Node | null;
+            setCurrentNode: (currentNode: Node) => void;
+            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/ any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/ any | null;
+        readonly previousSibling: /*elided*/ any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+        insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData | null) => void;
+        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+        updateChildren: () => void;
+        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        eachNode: (callback: (node: Node) => void) => void;
+        reInitChecked: () => void;
+    } | null, Node | {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/ any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+            currentNode: /*elided*/ any | null;
+            currentNodeKey: TreeKey | null;
+            nodesMap: import("./tree.type").TreeStoreNodesMap;
+            root: /*elided*/ any;
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("./tree.type").LoadFunction | undefined;
+            filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+            key: TreeKey;
+            defaultCheckedKeys?: TreeKey[] | undefined;
+            checkStrictly: boolean;
+            defaultExpandedKeys?: TreeKey[] | undefined;
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string | undefined;
+                label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                class?: ((data: TreeNodeData, node: Node) => string | {
+                    [key: string]: boolean;
+                }) | undefined;
+            };
+            initialize: () => void;
+            filter: (value: FilterValue) => void;
+            setData: (newVal: TreeData) => void;
+            getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+            remove: (data: TreeNodeData | Node) => void;
+            append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: Node) => void;
+            setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+            registerNode: (node: Node) => void;
+            deregisterNode: (node: Node) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => TreeKey[];
+            _getAllNodes: () => Node[];
+            updateChildren: (key: TreeKey, data: TreeData) => void;
+            _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => Node | null;
+            setCurrentNode: (currentNode: Node) => void;
+            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/ any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/ any | null;
+        readonly previousSibling: /*elided*/ any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+        insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData | null) => void;
+        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+        updateChildren: () => void;
+        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        eachNode: (callback: (node: Node) => void) => void;
+        reInitChecked: () => void;
+    } | null>;
+    dragState: import("vue").Ref<{
+        allowDrop: boolean;
+        dropType: import("./tree.type").NodeDropType | null;
+        draggingNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: TreeKey | null;
+                    nodesMap: import("./tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("./tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+                    key: TreeKey;
+                    defaultCheckedKeys?: TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: FilterValue) => void;
+                    setData: (newVal: TreeData) => void;
+                    getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+                    insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    remove: (data: TreeNodeData | Node) => void;
+                    append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: TreeKey, data: TreeData) => void;
+                    _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+        showDropIndicator: boolean;
+        dropNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: TreeKey | null;
+                    nodesMap: import("./tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("./tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+                    key: TreeKey;
+                    defaultCheckedKeys?: TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: FilterValue) => void;
+                    setData: (newVal: TreeData) => void;
+                    getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+                    insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    remove: (data: TreeNodeData | Node) => void;
+                    append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: TreeKey, data: TreeData) => void;
+                    _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+    }, {
+        allowDrop: boolean;
+        dropType: import("./tree.type").NodeDropType | null;
+        draggingNode: import("./model/useDragNode").TreeNode | null;
+        showDropIndicator: boolean;
+        dropNode: import("./model/useDragNode").TreeNode | null;
+    } | {
+        allowDrop: boolean;
+        dropType: import("./tree.type").NodeDropType | null;
+        draggingNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: TreeKey | null;
+                    nodesMap: import("./tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("./tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+                    key: TreeKey;
+                    defaultCheckedKeys?: TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: FilterValue) => void;
+                    setData: (newVal: TreeData) => void;
+                    getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+                    insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    remove: (data: TreeNodeData | Node) => void;
+                    append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: TreeKey, data: TreeData) => void;
+                    _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+        showDropIndicator: boolean;
+        dropNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: TreeKey | null;
+                    nodesMap: import("./tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("./tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+                    key: TreeKey;
+                    defaultCheckedKeys?: TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: FilterValue) => void;
+                    setData: (newVal: TreeData) => void;
+                    getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+                    insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+                    remove: (data: TreeNodeData | Node) => void;
+                    append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: TreeKey, data: TreeData) => void;
+                    _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("./tree.type").FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: import("./tree.type").FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+    }>;
+    el$: import("vue").Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
+    dropIndicator$: import("vue").Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
+    isEmpty: import("vue").ComputedRef<boolean>;
+    filter: (value: FilterValue) => void;
+    getNodeKey: (node: Node) => any;
+    getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
+    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getCurrentNode: () => TreeNodeData | null;
+    getCurrentKey: () => TreeKey | null;
+    setCheckedNodes: (nodes: Node[], leafOnly?: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep?: boolean) => void;
+    getHalfCheckedNodes: () => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+    setCurrentKey: (key?: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+    t: import("@element-plus/hooks").Translator;
+    getNode: (data: TreeKey | TreeNodeData) => Node;
+    remove: (data: TreeNodeData | Node) => void;
+    append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void;
+    insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
+    insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
+    handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
+    updateKeyChildren: (key: TreeKey, data: TreeData) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
+    'current-change': (data: any | null, node: Node | null) => boolean;
+    'node-click': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null, evt: MouseEvent) => any;
+    'node-contextmenu': (evt: Event, data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+    'node-collapse': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+    'node-expand': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+    check: (data: any, checkedInfo: import("./tree.type").CheckedInfo) => any;
+    'node-drag-start': (node: Node, evt: DragEvent) => DragEvent;
+    'node-drag-end': (draggingNode: Node, dropNode: Node | null, dropType: import("./tree.type").NodeDropType, evt: DragEvent) => DragEvent;
+    'node-drop': (draggingNode: Node, dropNode: Node, dropType: Exclude<import("./tree.type").NodeDropType, "none">, evt: DragEvent) => DragEvent;
+    'node-drag-leave': (draggingNode: Node, oldDropNode: Node, evt: DragEvent) => DragEvent;
+    'node-drag-enter': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
+    'node-drag-over': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly emptyText: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly renderAfterExpand: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly nodeKey: StringConstructor;
+    readonly checkStrictly: BooleanConstructor;
+    readonly defaultExpandAll: BooleanConstructor;
+    readonly expandOnClickNode: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly checkOnClickNode: BooleanConstructor;
+    readonly checkOnClickLeaf: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly checkDescendants: BooleanConstructor;
+    readonly autoExpandParent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly defaultCheckedKeys: {
+        readonly type: import("vue").PropType<TreeKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultExpandedKeys: {
+        readonly type: import("vue").PropType<TreeKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly currentNodeKey: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly renderContent: {
+        readonly type: import("vue").PropType<import("./tree.type").RenderContentFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly showCheckbox: BooleanConstructor;
+    readonly draggable: BooleanConstructor;
+    readonly allowDrag: {
+        readonly type: import("vue").PropType<import("./tree.type").AllowDragFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly allowDrop: {
+        readonly type: import("vue").PropType<import("./tree.type").AllowDropFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("./tree.type").TreeOptionProps) | (() => import("./tree.type").TreeOptionProps) | (((new (...args: any[]) => import("./tree.type").TreeOptionProps) | (() => import("./tree.type").TreeOptionProps)) | null)[], unknown, unknown, () => {
+        children: string;
+        label: string;
+        disabled: string;
+    }, boolean>;
+    readonly lazy: BooleanConstructor;
+    readonly highlightCurrent: BooleanConstructor;
+    readonly load: {
+        readonly type: import("vue").PropType<import("./tree.type").LoadFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly filterNodeMethod: {
+        readonly type: import("vue").PropType<import("./tree.type").FilterNodeMethodFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly accordion: BooleanConstructor;
+    readonly indent: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{
+    onCheck?: ((data: any, checkedInfo: import("./tree.type").CheckedInfo) => any) | undefined;
+    "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
+    "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
+    "onNode-click"?: ((data: any, node: Node, nodeInstance: ComponentInternalInstance | null, evt: MouseEvent) => any) | undefined;
+    "onNode-contextmenu"?: ((evt: Event, data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any) | undefined;
+    "onNode-collapse"?: ((data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any) | undefined;
+    "onNode-expand"?: ((data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any) | undefined;
+    "onNode-drag-start"?: ((node: Node, evt: DragEvent) => any) | undefined;
+    "onNode-drag-end"?: ((draggingNode: Node, dropNode: Node | null, dropType: import("./tree.type").NodeDropType, evt: DragEvent) => any) | undefined;
+    "onNode-drop"?: ((draggingNode: Node, dropNode: Node, dropType: "after" | "before" | "inner", evt: DragEvent) => any) | undefined;
+    "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
+    "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
+    "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
+}>, {
+    readonly data: TreeData;
+    readonly props: import("./tree.type").TreeOptionProps;
+    readonly draggable: boolean;
+    readonly lazy: boolean;
+    readonly checkStrictly: boolean;
+    readonly checkOnClickNode: boolean;
+    readonly checkOnClickLeaf: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly accordion: boolean;
+    readonly indent: number;
+    readonly defaultExpandAll: boolean;
+    readonly autoExpandParent: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly checkDescendants: boolean;
+    readonly renderAfterExpand: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly expandOnClickNode: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showCheckbox: boolean;
+    readonly highlightCurrent: boolean;
+}, {}, {
+    EpTreeNode: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        node: {
+            type: typeof Node;
+            default: () => {};
+        };
+        props: {
+            type: import("vue").PropType<import("./tree.type").TreeOptionProps>;
+            default: () => {};
+        };
+        accordion: BooleanConstructor;
+        renderContent: FunctionConstructor;
+        renderAfterExpand: BooleanConstructor;
+        showCheckbox: BooleanConstructor;
+    }>, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        node$: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        tree: import("./tree.type").RootTreeType;
+        expanded: import("vue").Ref<boolean, boolean>;
+        childNodeRendered: import("vue").Ref<boolean, boolean>;
+        oldChecked: import("vue").Ref<boolean | undefined, boolean | undefined>;
+        oldIndeterminate: import("vue").Ref<boolean | undefined, boolean | undefined>;
+        getNodeKey: (node: Node) => any;
+        getNodeClass: (node: Node) => {
+            [key: string]: boolean;
+        };
+        handleSelectChange: (checked: boolean, indeterminate: boolean) => void;
+        handleClick: (e: MouseEvent) => void;
+        handleContextMenu: (event: Event) => void;
+        handleExpandIconClick: () => void;
+        handleCheckChange: (value: import("../../checkbox").CheckboxValueType) => void;
+        handleChildNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
+        handleDragStart: (event: DragEvent) => void;
+        handleDragOver: (event: DragEvent) => void;
+        handleDrop: (event: DragEvent) => void;
+        handleDragEnd: (event: DragEvent) => void;
+        CaretRight: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "node-expand"[], "node-expand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        node: {
+            type: typeof Node;
+            default: () => {};
+        };
+        props: {
+            type: import("vue").PropType<import("./tree.type").TreeOptionProps>;
+            default: () => {};
+        };
+        accordion: BooleanConstructor;
+        renderContent: FunctionConstructor;
+        renderAfterExpand: BooleanConstructor;
+        showCheckbox: BooleanConstructor;
+    }>> & Readonly<{
+        "onNode-expand"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: import("./tree.type").TreeOptionProps;
+        node: Node;
+        accordion: boolean;
+        renderAfterExpand: boolean;
+        showCheckbox: boolean;
+    }, {}, {
+        ElCollapseTransition: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) & import("vue").Plugin;
+        ElCheckbox: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                ariaLabel: StringConstructor;
+            }>> & Readonly<{
+                "onUpdate:modelValue"?: ((val: import("../../checkbox").CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import("../../checkbox").CheckboxValueType) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (val: import("../../checkbox").CheckboxValueType) => void;
+                change: (val: import("../../checkbox").CheckboxValueType) => void;
+            }, import("vue").PublicProps, {
+                name: string;
+                border: boolean;
+                disabled: boolean;
+                label: string | number | boolean | Record<string, any>;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                ariaLabel: StringConstructor;
+            }>> & Readonly<{
+                "onUpdate:modelValue"?: ((val: import("../../checkbox").CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import("../../checkbox").CheckboxValueType) => any) | undefined;
+            }>, {}, {}, {}, {}, {
+                name: string;
+                border: boolean;
+                disabled: boolean;
+                label: string | number | boolean | Record<string, any>;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (NumberConstructor | StringConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            ariaLabel: StringConstructor;
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((val: import("../../checkbox").CheckboxValueType) => any) | undefined;
+            onChange?: ((val: import("../../checkbox").CheckboxValueType) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: import("../../checkbox").CheckboxValueType) => void;
+            change: (val: import("../../checkbox").CheckboxValueType) => void;
+        }, string, {
+            name: string;
+            border: boolean;
+            disabled: boolean;
+            label: string | number | boolean | Record<string, any>;
+            value: string | number | boolean | Record<string, any>;
+            id: string;
+            modelValue: string | number | boolean;
+            validateEvent: boolean;
+            indeterminate: boolean;
+            checked: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) & import("vue").Plugin;
+        NodeContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            node: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            renderContent: FunctionConstructor;
+        }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            node: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            renderContent: FunctionConstructor;
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElIcon: import("@element-plus/utils").SFCWithInstall<{
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        })>;
+        Loading: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;