@vtj/designer 0.20.5 → 0.20.7

package/types/components/widgets/index.d.ts

@@ -1,8 +1,13 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, Ref, CreateComponentPublicInstanceWithMixins, GlobalComponents, GlobalDirectives, ComputedRef, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Attrs, Slot, ComponentPublicInstance, ComponentOptionsBase, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ComponentCustomProperties, ExtractPropTypes, PropType, VNode, RendererNode, RendererElement, ShallowRef } from 'vue';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, Ref, CreateComponentPublicInstanceWithMixins, GlobalComponents, GlobalDirectives, ExtractPropTypes, PropType, Component, ComponentInternalInstance, ComputedRef, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps, ObjectPlugin, Attrs, Slot, ComponentPublicInstance, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ComponentCustomProperties, VNode, RendererNode, RendererElement, ShallowRef } from 'vue';
 import { Props } from './logo/index';
 import { Props } from './toolbar/index';
 import { Props } from './actions/index';
 import { Props } from './actions/versioner‌';
+import { EpPropFinalized, EpPropMergeType, SFCWithInstall } from 'element-plus/es/utils/index.mjs';
+import { TreeData, TreeKey, RenderContentFunction, AllowDragFunction, AllowDropFunction, TreeOptionProps, LoadFunction, FilterNodeMethodFunction, CheckedInfo, NodeDropType, TreeNodeData, FakeNode, TreeNodeLoadedDefaultProps, TreeStoreNodesMap, FilterValue, Nullable, Translator, RootTreeType, CheckboxValueType, CheckboxProps, ComponentSize, CheckboxGroupProps, CheckboxGroupValueType, IconProps, MessageBoxData } from 'element-plus';
+import { Node } from 'element-plus/es/components/tree/src/model/node.mjs';
+import { TreeStore } from 'element-plus/es/components/tree/src/model/tree-store.mjs';
+import { TreeNode } from 'element-plus/es/components/tree/src/model/useDragNode.mjs';
 import { Designer } from '../..';
 import { Props } from '../shared/viewport';
 import { OnCleanup } from '@vue/reactivity';
@@ -16,7 +21,6 @@ import { Props } from './about/index';
 import { Props } from './agent/pay-tip';
 import { Options } from 'sortablejs';
 import { VxeTableProps, VxeGridEventProps, VxeGridSlots, VxeTableDataRow, SlotVNodeType, VxeGridInstance, VxeTableConstructor, VxeGridConstructor } from 'vxe-table';
-import { MessageBoxData } from 'element-plus';
 import { UseMouseSourceType, Position } from '@vueuse/core';
 export declare const widgets: {
     Logo: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< Props> & Readonly<{}>, {
@@ -79,7 +83,2038 @@ export declare const widgets: {
     }, any>;
     Blocks: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
     Components: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
-    Outline: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+    Outline: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+        treeRef: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+            readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
+            readonly emptyText: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly renderAfterExpand: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly nodeKey: StringConstructor;
+            readonly checkStrictly: BooleanConstructor;
+            readonly defaultExpandAll: BooleanConstructor;
+            readonly expandOnClickNode: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly checkOnClickNode: BooleanConstructor;
+            readonly checkOnClickLeaf: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly checkDescendants: BooleanConstructor;
+            readonly autoExpandParent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly defaultCheckedKeys: {
+                readonly type: PropType< TreeKey[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly defaultExpandedKeys: {
+                readonly type: PropType< TreeKey[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly currentNodeKey: {
+                readonly type: PropType<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: PropType<RenderContentFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly showCheckbox: BooleanConstructor;
+            readonly draggable: BooleanConstructor;
+            readonly allowDrag: {
+                readonly type: PropType<AllowDragFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly allowDrop: {
+                readonly type: PropType<AllowDropFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly props: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | (((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps)) | null)[], unknown, unknown, () => {
+                children: string;
+                label: string;
+                disabled: string;
+            }, boolean>;
+            readonly lazy: BooleanConstructor;
+            readonly highlightCurrent: BooleanConstructor;
+            readonly load: {
+                readonly type: PropType<LoadFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly filterNodeMethod: {
+                readonly type: PropType<FilterNodeMethodFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly accordion: BooleanConstructor;
+            readonly indent: EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
+            readonly icon: {
+                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{
+            "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
+            "onNode-expand"?: ((data: any, node: Node, nodeInstance: ComponentInternalInstance | 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;
+            onCheck?: ((data: any, checkedInfo: CheckedInfo) => any) | undefined;
+            "onNode-drag-start"?: ((node: Node, evt: DragEvent) => any) | undefined;
+            "onNode-drag-end"?: ((draggingNode: Node, dropNode: Node | null, dropType: NodeDropType, evt: DragEvent) => any) | undefined;
+            "onNode-drop"?: ((draggingNode: Node, dropNode: Node, dropType: "after" | "before" | "inner", evt: DragEvent) => any) | undefined;
+            "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
+            "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
+            "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
+        }>, {
+            ns: {
+                namespace: 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: Ref<{
+                currentNode: {
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                } | null;
+                currentNodeKey: TreeKey | null;
+                nodesMap: TreeStoreNodesMap;
+                root: {
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                };
+                data: TreeNodeData[];
+                lazy: boolean;
+                load?: LoadFunction | undefined;
+                filterNodeMethod?: 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: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                } | null;
+                currentNodeKey: TreeKey | null;
+                nodesMap: TreeStoreNodesMap;
+                root: {
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                };
+                data: TreeNodeData[];
+                lazy: boolean;
+                load?: LoadFunction | undefined;
+                filterNodeMethod?: 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: Ref<{
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            }, Node | {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            }>;
+            currentNode: Ref<{
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            } | null, Node | {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            } | null>;
+            dragState: Ref<{
+                allowDrop: boolean;
+                dropType: NodeDropType | null;
+                draggingNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+                showDropIndicator: boolean;
+                dropNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+            }, {
+                allowDrop: boolean;
+                dropType: NodeDropType | null;
+                draggingNode: TreeNode | null;
+                showDropIndicator: boolean;
+                dropNode: TreeNode | null;
+            } | {
+                allowDrop: boolean;
+                dropType: NodeDropType | null;
+                draggingNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+                showDropIndicator: boolean;
+                dropNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+            }>;
+            el$: Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
+            dropIndicator$: Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
+            isEmpty: 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: 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;
+        }, {}, {}, {}, ComponentOptionsMixin, 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: CheckedInfo) => any;
+            'node-drag-start': (node: Node, evt: DragEvent) => DragEvent;
+            'node-drag-end': (draggingNode: Node, dropNode: Node | null, dropType: NodeDropType, evt: DragEvent) => DragEvent;
+            'node-drop': (draggingNode: Node, dropNode: Node, dropType: Exclude< 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;
+        }, PublicProps, {
+            readonly lazy: boolean;
+            readonly props: TreeOptionProps;
+            readonly data: TreeData;
+            readonly checkStrictly: boolean;
+            readonly checkOnClickNode: boolean;
+            readonly checkOnClickLeaf: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly accordion: boolean;
+            readonly draggable: boolean;
+            readonly defaultExpandAll: boolean;
+            readonly indent: number;
+            readonly renderAfterExpand: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showCheckbox: boolean;
+            readonly expandOnClickNode: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly autoExpandParent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly checkDescendants: boolean;
+            readonly highlightCurrent: boolean;
+        }, true, {}, {}, {
+            ElTreeNode: DefineComponent<ExtractPropTypes<{
+                node: {
+                    type: Node;
+                    default: () => {};
+                };
+                props: {
+                    type: PropType<TreeOptionProps>;
+                    default: () => {};
+                };
+                accordion: BooleanConstructor;
+                renderContent: FunctionConstructor;
+                renderAfterExpand: BooleanConstructor;
+                showCheckbox: BooleanConstructor;
+            }>, {
+                ns: {
+                    namespace: 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$: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                tree: RootTreeType;
+                expanded: Ref<boolean, boolean>;
+                childNodeRendered: Ref<boolean, boolean>;
+                oldChecked: Ref<boolean | undefined, boolean | undefined>;
+                oldIndeterminate: 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: 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: DefineComponent<{}, void, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "node-expand"[], "node-expand", PublicProps, Readonly< ExtractPropTypes<{
+                node: {
+                    type: Node;
+                    default: () => {};
+                };
+                props: {
+                    type: PropType<TreeOptionProps>;
+                    default: () => {};
+                };
+                accordion: BooleanConstructor;
+                renderContent: FunctionConstructor;
+                renderAfterExpand: BooleanConstructor;
+                showCheckbox: BooleanConstructor;
+            }>> & Readonly<{
+                "onNode-expand"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                props: TreeOptionProps;
+                accordion: boolean;
+                node: Node;
+                renderAfterExpand: boolean;
+                showCheckbox: boolean;
+            }, {}, {
+                ElCollapseTransition: SFCWithInstall<{
+                    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                })>;
+                ElCheckbox: {
+                    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< CheckboxProps> & Readonly<{
+                        onChange?: ((val: CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                        change: (val: CheckboxValueType) => void;
+                        "update:modelValue": (val: CheckboxValueType) => void;
+                    }, PublicProps, {
+                        id: string;
+                        disabled: boolean;
+                        modelValue: number | string | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        value: string | boolean | number | object;
+                        label: string | boolean | number | object;
+                        trueValue: string | number;
+                        falseValue: string | number;
+                        trueLabel: string | number;
+                        falseLabel: string | number;
+                    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly< CheckboxProps> & Readonly<{
+                        onChange?: ((val: CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, {
+                        id: string;
+                        disabled: boolean;
+                        modelValue: number | string | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        value: string | boolean | number | object;
+                        label: string | boolean | number | object;
+                        trueValue: string | number;
+                        falseValue: string | number;
+                        trueLabel: string | number;
+                        falseLabel: string | number;
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & ComponentOptionsBase<Readonly< CheckboxProps> & Readonly<{
+                    onChange?: ((val: CheckboxValueType) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+                }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                    change: (val: CheckboxValueType) => void;
+                    "update:modelValue": (val: CheckboxValueType) => void;
+                }, string, {
+                    id: string;
+                    disabled: boolean;
+                    modelValue: number | string | boolean;
+                    validateEvent: boolean;
+                    name: string;
+                    value: string | boolean | number | object;
+                    label: string | boolean | number | object;
+                    trueValue: string | number;
+                    falseValue: string | number;
+                    trueLabel: string | number;
+                    falseLabel: string | number;
+                }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                }) & ObjectPlugin & {
+                    setPropsDefaults: (defaults: Partial<Omit<{
+                        readonly modelValue?: (number | string | boolean) | undefined;
+                        readonly label?: (string | boolean | number | object) | undefined;
+                        readonly value?: (string | boolean | number | object) | undefined;
+                        readonly indeterminate?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly checked?: boolean | undefined;
+                        readonly name?: string | undefined;
+                        readonly trueValue?: (string | number) | undefined;
+                        readonly falseValue?: (string | number) | undefined;
+                        readonly trueLabel?: (string | number) | undefined;
+                        readonly falseLabel?: (string | number) | undefined;
+                        readonly id?: string | undefined;
+                        readonly border?: boolean | undefined;
+                        readonly size?: ComponentSize | undefined;
+                        readonly tabindex?: (string | number) | undefined;
+                        readonly validateEvent?: boolean | undefined;
+                        readonly ariaLabel?: string | undefined;
+                        readonly ariaControls?: string | undefined;
+                        readonly onChange?: ((val: CheckboxValueType) => any) | undefined;
+                        readonly "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+                    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "onChange" | "onUpdate:modelValue" | keyof VNodeProps | keyof AllowedComponentProps>>) => void;
+                } & {
+                    CheckboxButton: {
+                        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< CheckboxProps> & Readonly<{
+                            onChange?: ((val: CheckboxValueType) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                            change: (val: CheckboxValueType) => void;
+                            "update:modelValue": (val: CheckboxValueType) => void;
+                        }, PublicProps, {
+                            id: string;
+                            disabled: boolean;
+                            modelValue: number | string | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            value: string | boolean | number | object;
+                            label: string | boolean | number | object;
+                            trueValue: string | number;
+                            falseValue: string | number;
+                            trueLabel: string | number;
+                            falseLabel: string | number;
+                        }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly< CheckboxProps> & Readonly<{
+                            onChange?: ((val: CheckboxValueType) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, {
+                            id: string;
+                            disabled: boolean;
+                            modelValue: number | string | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            value: string | boolean | number | object;
+                            label: string | boolean | number | object;
+                            trueValue: string | number;
+                            falseValue: string | number;
+                            trueLabel: string | number;
+                            falseLabel: string | number;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & ComponentOptionsBase<Readonly< CheckboxProps> & Readonly<{
+                        onChange?: ((val: CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                        change: (val: CheckboxValueType) => void;
+                        "update:modelValue": (val: CheckboxValueType) => void;
+                    }, string, {
+                        id: string;
+                        disabled: boolean;
+                        modelValue: number | string | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        value: string | boolean | number | object;
+                        label: string | boolean | number | object;
+                        trueValue: string | number;
+                        falseValue: string | number;
+                        trueLabel: string | number;
+                        falseLabel: string | number;
+                    }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    });
+                    CheckboxGroup: {
+                        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< CheckboxGroupProps> & Readonly<{
+                            onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: CheckboxGroupValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                            change: (val: CheckboxValueType[]) => void;
+                            "update:modelValue": (val: CheckboxGroupValueType) => void;
+                        }, PublicProps, {
+                            props: {
+                                value?: string;
+                                label?: string;
+                                disabled?: string;
+                            };
+                            type: "checkbox" | "button";
+                            disabled: boolean;
+                            modelValue: CheckboxGroupValueType;
+                            validateEvent: boolean;
+                            tag: string;
+                        }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly< CheckboxGroupProps> & Readonly<{
+                            onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: CheckboxGroupValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, {
+                            props: {
+                                value?: string;
+                                label?: string;
+                                disabled?: string;
+                            };
+                            type: "checkbox" | "button";
+                            disabled: boolean;
+                            modelValue: CheckboxGroupValueType;
+                            validateEvent: boolean;
+                            tag: string;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & ComponentOptionsBase<Readonly< CheckboxGroupProps> & Readonly<{
+                        onChange?: ((val: CheckboxValueType[]) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: CheckboxGroupValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                        change: (val: CheckboxValueType[]) => void;
+                        "update:modelValue": (val: CheckboxGroupValueType) => void;
+                    }, string, {
+                        props: {
+                            value?: string;
+                            label?: string;
+                            disabled?: string;
+                        };
+                        type: "checkbox" | "button";
+                        disabled: boolean;
+                        modelValue: CheckboxGroupValueType;
+                        validateEvent: boolean;
+                        tag: string;
+                    }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    });
+                };
+                NodeContent: DefineComponent<ExtractPropTypes<{
+                    node: {
+                        type: ObjectConstructor;
+                        required: true;
+                    };
+                    renderContent: FunctionConstructor;
+                }>, () => any, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+                    node: {
+                        type: ObjectConstructor;
+                        required: true;
+                    };
+                    renderContent: FunctionConstructor;
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+                ElIcon: SFCWithInstall<{
+                    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< IconProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly< IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & ComponentOptionsBase<Readonly< IconProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                })>;
+                Loading: DefineComponent<{}, void, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+            }, {}, string, ComponentProvideOptions, true, {}, any>;
+        } & GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< ExtractPropTypes<{
+            readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
+            readonly emptyText: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly renderAfterExpand: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly nodeKey: StringConstructor;
+            readonly checkStrictly: BooleanConstructor;
+            readonly defaultExpandAll: BooleanConstructor;
+            readonly expandOnClickNode: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly checkOnClickNode: BooleanConstructor;
+            readonly checkOnClickLeaf: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly checkDescendants: BooleanConstructor;
+            readonly autoExpandParent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly defaultCheckedKeys: {
+                readonly type: PropType< TreeKey[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly defaultExpandedKeys: {
+                readonly type: PropType< TreeKey[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly currentNodeKey: {
+                readonly type: PropType<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: PropType<RenderContentFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly showCheckbox: BooleanConstructor;
+            readonly draggable: BooleanConstructor;
+            readonly allowDrag: {
+                readonly type: PropType<AllowDragFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly allowDrop: {
+                readonly type: PropType<AllowDropFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly props: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | (((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps)) | null)[], unknown, unknown, () => {
+                children: string;
+                label: string;
+                disabled: string;
+            }, boolean>;
+            readonly lazy: BooleanConstructor;
+            readonly highlightCurrent: BooleanConstructor;
+            readonly load: {
+                readonly type: PropType<LoadFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly filterNodeMethod: {
+                readonly type: PropType<FilterNodeMethodFunction>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly accordion: BooleanConstructor;
+            readonly indent: EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
+            readonly icon: {
+                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{
+            "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
+            "onNode-expand"?: ((data: any, node: Node, nodeInstance: ComponentInternalInstance | 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;
+            onCheck?: ((data: any, checkedInfo: CheckedInfo) => any) | undefined;
+            "onNode-drag-start"?: ((node: Node, evt: DragEvent) => any) | undefined;
+            "onNode-drag-end"?: ((draggingNode: Node, dropNode: Node | null, dropType: NodeDropType, evt: DragEvent) => any) | undefined;
+            "onNode-drop"?: ((draggingNode: Node, dropNode: Node, dropType: "after" | "before" | "inner", evt: DragEvent) => any) | undefined;
+            "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
+            "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
+            "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
+        }>, {
+            ns: {
+                namespace: 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: Ref<{
+                currentNode: {
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                } | null;
+                currentNodeKey: TreeKey | null;
+                nodesMap: TreeStoreNodesMap;
+                root: {
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                };
+                data: TreeNodeData[];
+                lazy: boolean;
+                load?: LoadFunction | undefined;
+                filterNodeMethod?: 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: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                } | null;
+                currentNodeKey: TreeKey | null;
+                nodesMap: TreeStoreNodesMap;
+                root: {
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    isEffectivelyChecked: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: Node, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                    insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: Node) => void) => void;
+                    reInitChecked: () => void;
+                };
+                data: TreeNodeData[];
+                lazy: boolean;
+                load?: LoadFunction | undefined;
+                filterNodeMethod?: 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: Ref<{
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            }, Node | {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            }>;
+            currentNode: Ref<{
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            } | null, Node | {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            } | null>;
+            dragState: Ref<{
+                allowDrop: boolean;
+                dropType: NodeDropType | null;
+                draggingNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+                showDropIndicator: boolean;
+                dropNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+            }, {
+                allowDrop: boolean;
+                dropType: NodeDropType | null;
+                draggingNode: TreeNode | null;
+                showDropIndicator: boolean;
+                dropNode: TreeNode | null;
+            } | {
+                allowDrop: boolean;
+                dropType: NodeDropType | null;
+                draggingNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+                showDropIndicator: boolean;
+                dropNode: {
+                    node: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        isEffectivelyChecked: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: Node, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                        insertAfter: (child: 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?: 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?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: Node) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    $el?: HTMLElement | undefined;
+                } | null;
+            }>;
+            el$: Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
+            dropIndicator$: Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
+            isEmpty: 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: 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;
+        }, {}, {}, {}, {
+            readonly lazy: boolean;
+            readonly props: TreeOptionProps;
+            readonly data: TreeData;
+            readonly checkStrictly: boolean;
+            readonly checkOnClickNode: boolean;
+            readonly checkOnClickLeaf: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly accordion: boolean;
+            readonly draggable: boolean;
+            readonly defaultExpandAll: boolean;
+            readonly indent: number;
+            readonly renderAfterExpand: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showCheckbox: boolean;
+            readonly expandOnClickNode: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly autoExpandParent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly checkDescendants: boolean;
+            readonly highlightCurrent: boolean;
+        }> | null;
+    }, any>;
     History: DefineComponent<{}, {
         openAdd: () => void;
     }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
@@ -2971,8 +5006,8 @@ export declare const widgets: {
                 size: BaseSize;
                 primary: boolean;
                 mode: DialogMode;
-                pure: boolean;
                 draggable: boolean | DraggableOptions;
+                pure: boolean;
                 width: string | number;
                 height: string | number;
                 modelValue: boolean;
@@ -2989,12 +5024,12 @@ export declare const widgets: {
                 readonly modelValue: boolean;
                 readonly mode: DialogMode;
                 readonly draggable: boolean | DraggableOptions;
-                readonly pure: boolean;
                 readonly closable: boolean;
                 readonly modal: boolean;
                 readonly maximizable: boolean;
                 readonly minimizable: boolean;
                 readonly bodyPadding: boolean;
+                readonly pure: boolean;
                 readonly left?: string | number | undefined;
                 readonly icon?: IconParam | undefined;
                 readonly zIndex?: number | undefined;
@@ -3003,11 +5038,11 @@ export declare const widgets: {
                 readonly cancel?: string | boolean | undefined;
                 readonly beforeClose?: (() => boolean | Promise<boolean>) | undefined;
                 readonly src?: string | undefined;
+                readonly subtitle?: string | undefined;
+                readonly submit?: string | boolean | undefined;
                 readonly content?: Record<string, any> | VNode<RendererNode, RendererElement, {
                     [key: string]: any;
                 }> | DefineComponent<any, any, any, any> | undefined;
-                readonly subtitle?: string | undefined;
-                readonly submit?: string | boolean | undefined;
                 readonly resizable?: boolean | ResizableOptions | undefined;
                 readonly componentInstance?: Record<string, any> | null | undefined;
                 readonly onClose?: (() => any) | undefined | undefined;
@@ -3062,7 +5097,7 @@ export declare const widgets: {
                     isOutside: ShallowRef<boolean, boolean>;
                     stop: () => void;
                 }) => any) | undefined | undefined;
-            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "height" | "width" | "primary" | "size" | "modelValue" | "mode" | "draggable" | "pure" | "closable" | "modal" | "maximizable" | "minimizable" | "bodyPadding">;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "height" | "width" | "primary" | "size" | "modelValue" | "mode" | "draggable" | "closable" | "modal" | "maximizable" | "minimizable" | "bodyPadding" | "pure">;
             $attrs: Attrs;
             $refs: {
                 [x: string]: unknown;
@@ -3637,7 +5672,7 @@ export declare const widgets: {
             $root: ComponentPublicInstance | null;
             $parent: ComponentPublicInstance | null;
             $host: Element | null;
-            $emit: ((event: "close") => void) & ((event: "cancel") => void) & ((event: "open", instance: ComponentInternalInstance) => void) & ((event: "update:modelValue", value: boolean) => void) & ((event: "submit") => void) & ((event: "maximized") => void) & ((event: "minimized") => void) & ((event: "resizing", dir: string, mie: {
+            $emit: ((event: "close") => void) & ((event: "cancel") => void) & ((event: "update:modelValue", value: boolean) => void) & ((event: "submit") => void) & ((event: "maximized") => void) & ((event: "minimized") => void) & ((event: "open", instance: ComponentInternalInstance) => void) & ((event: "resizing", dir: string, mie: {
                 x: ShallowRef<number, number>;
                 y: ShallowRef<number, number>;
                 sourceType: ShallowRef<UseMouseSourceType, UseMouseSourceType>;
@@ -3902,8 +5937,8 @@ export declare const widgets: {
                 size: BaseSize;
                 primary: boolean;
                 mode: DialogMode;
-                pure: boolean;
                 draggable: boolean | DraggableOptions;
+                pure: boolean;
                 width: string | number;
                 height: string | number;
                 modelValue: boolean;
@@ -3936,8 +5971,8 @@ export declare const widgets: {
             size: BaseSize;
             primary: boolean;
             mode: DialogMode;
-            pure: boolean;
             draggable: boolean | DraggableOptions;
+            pure: boolean;
             width: string | number;
             height: string | number;
             modelValue: boolean;
@@ -4089,7 +6124,7 @@ export declare const widgets: {
                 isOutside: ShallowRef<boolean, boolean>;
                 stop: () => void;
             }) => any) | undefined;
-        }>, "height" | "width" | "primary" | "close" | "cancel" | "size" | "modelValue" | "mode" | "draggable" | "pure" | "submit" | "$vtjEl" | "closable" | "modal" | "maximizable" | "minimizable" | "componentInstance" | "bodyPadding" | "panelRef" | "state" | "maximized" | "minimized" | "changeMode" | "show" | "hide" | "iframeRef"> & {
+        }>, "height" | "width" | "primary" | "close" | "cancel" | "size" | "modelValue" | "mode" | "draggable" | "submit" | "$vtjEl" | "closable" | "modal" | "maximizable" | "minimizable" | "componentInstance" | "bodyPadding" | "pure" | "panelRef" | "state" | "maximized" | "minimized" | "changeMode" | "show" | "hide" | "iframeRef"> & {
             $vtjEl: any;
             panelRef: any;
             state: {