@jari-ace/element-plus-component 0.3.1 → 0.3.3

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

@@ -0,0 +1,1808 @@
+import { type Group } from "@jari-ace/app-bolts";
+import type { TreeNodeData } from "element-plus/es/components/tree/src/tree.type";
+interface Props {
+    /**
+     * 用户域ID
+     */
+    realmId?: string;
+    /**
+     * 是否多选
+     */
+    multiple?: boolean;
+    /**
+     * 是否显示控制台应用
+     */
+    showConsoleApp?: boolean;
+    /**
+     * 只显示指定应用下的用户组（不可自选应用）
+     */
+    appId?: string;
+    /**
+     * 节点高度
+     */
+    nodeHeight?: string;
+    /**
+     * 业务类别
+     */
+    category?: string;
+    /**
+     * 是否全局用户组
+     */
+    global?: boolean;
+    /**
+     * 是否显示所有分类
+     */
+    showAllCategory?: boolean;
+}
+type __VLS_Props = Props;
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue?: Group | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {
+    reload: () => Promise<void>;
+    elTree: import("vue").Ref<import("element-plus/es/utils/index.mjs").SFCWithInstall<import("vue").DefineComponent<{
+        data: {
+            type: import("vue").PropType<import("element-plus").TreeData>;
+            default: () => never[];
+        };
+        emptyText: {
+            type: StringConstructor;
+        };
+        renderAfterExpand: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nodeKey: StringConstructor;
+        checkStrictly: BooleanConstructor;
+        defaultExpandAll: BooleanConstructor;
+        expandOnClickNode: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkOnClickNode: BooleanConstructor;
+        checkOnClickLeaf: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkDescendants: BooleanConstructor;
+        autoExpandParent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        defaultCheckedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        defaultExpandedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        currentNodeKey: import("vue").PropType<string | number>;
+        renderContent: {
+            type: import("vue").PropType<import("element-plus").RenderContentFunction>;
+        };
+        showCheckbox: BooleanConstructor;
+        draggable: BooleanConstructor;
+        allowDrag: {
+            type: import("vue").PropType<import("element-plus").AllowDragFunction>;
+        };
+        allowDrop: {
+            type: import("vue").PropType<import("element-plus").AllowDropFunction>;
+        };
+        props: {
+            /**
+             * 只显示指定应用下的用户组（不可自选应用）
+             */
+            type: import("vue").PropType<import("element-plus").TreeOptionProps>;
+            default: () => {
+                children: string;
+                label: string;
+                disabled: string;
+            };
+        };
+        lazy: BooleanConstructor;
+        highlightCurrent: BooleanConstructor;
+        load: import("vue").PropType<import("element-plus").LoadFunction>;
+        filterNodeMethod: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
+        accordion: BooleanConstructor;
+        indent: {
+            type: NumberConstructor;
+            default: number;
+        };
+        icon: {
+            type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>>;
+        };
+    }, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        store: import("vue").Ref<{
+            currentNode: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            currentNodeKey: import("element-plus").TreeKey;
+            nodesMap: import("element-plus").TreeStoreNodesMap;
+            root: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean; /**
+                 * 业务类别
+                 */
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("element-plus").LoadFunction;
+            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction;
+            key: import("element-plus").TreeKey;
+            defaultCheckedKeys?: import("element-plus").TreeKey[];
+            checkStrictly: boolean;
+            defaultExpandedKeys?: import("element-plus").TreeKey[];
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string;
+                label?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string);
+                disabled?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                isLeaf?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                class?: (data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string | {
+                    [key: string]: boolean;
+                };
+            };
+            initialize: () => void;
+            filter: (value: any) => void;
+            setData: (newVal: import("element-plus").TreeData) => void;
+            getNode: (data: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            insertBefore: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            remove: (data: TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            append: (data: TreeNodeData, parentData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setDefaultCheckedKey: (newVal: import("element-plus").TreeKey[]) => void;
+            registerNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            deregisterNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => import("element-plus").TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => import("element-plus").TreeKey[];
+            _getAllNodes: () => import("element-plus/es/components/tree/src/model/node.mjs").default[];
+            updateChildren: (key: import("element-plus").TreeKey, data: import("element-plus").TreeData) => void;
+            _setCheckedKeys: (key: import("element-plus").TreeKey, leafOnly: boolean, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: import("element-plus/es/components/tree/src/model/node.mjs").default[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: import("element-plus").TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: import("element-plus").TreeKey[]) => void;
+            setChecked: (data: import("element-plus").TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            setCurrentNode: (currentNode: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setUserCurrentNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: import("element-plus").TreeKey, shouldAutoExpandParent?: boolean) => void;
+        }, {
+            currentNode: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            currentNodeKey: import("element-plus").TreeKey;
+            nodesMap: import("element-plus").TreeStoreNodesMap;
+            root: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean; /**
+                 * 业务类别
+                 */
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("element-plus").LoadFunction;
+            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction;
+            key: import("element-plus").TreeKey;
+            defaultCheckedKeys?: import("element-plus").TreeKey[];
+            checkStrictly: boolean;
+            defaultExpandedKeys?: import("element-plus").TreeKey[];
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string;
+                label?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string);
+                disabled?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                isLeaf?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                class?: (data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string | {
+                    [key: string]: boolean;
+                };
+            };
+            initialize: () => void;
+            filter: (value: any) => void;
+            setData: (newVal: import("element-plus").TreeData) => void;
+            getNode: (data: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            insertBefore: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            remove: (data: TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            append: (data: TreeNodeData, parentData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setDefaultCheckedKey: (newVal: import("element-plus").TreeKey[]) => void;
+            registerNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            deregisterNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => import("element-plus").TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => import("element-plus").TreeKey[];
+            _getAllNodes: () => import("element-plus/es/components/tree/src/model/node.mjs").default[];
+            updateChildren: (key: import("element-plus").TreeKey, data: import("element-plus").TreeData) => void;
+            _setCheckedKeys: (key: import("element-plus").TreeKey, leafOnly: boolean, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: import("element-plus/es/components/tree/src/model/node.mjs").default[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: import("element-plus").TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: import("element-plus").TreeKey[]) => void;
+            setChecked: (data: import("element-plus").TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            setCurrentNode: (currentNode: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setUserCurrentNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: import("element-plus").TreeKey, shouldAutoExpandParent?: boolean) => void;
+        }>;
+        root: import("vue").Ref<{
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }, {
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }>;
+        currentNode: import("vue").Ref<{
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }, {
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }>;
+        dragState: import("vue").Ref<{
+            allowDrop: boolean;
+            dropType: import("element-plus").NodeDropType;
+            draggingNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+            showDropIndicator: boolean;
+            dropNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+        }, {
+            allowDrop: boolean;
+            dropType: import("element-plus").NodeDropType;
+            draggingNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+            showDropIndicator: boolean;
+            dropNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+        }>;
+        el$: import("vue").Ref<HTMLElement, HTMLElement>;
+        dropIndicator$: import("vue").Ref<HTMLElement, HTMLElement>;
+        isEmpty: import("vue").ComputedRef<boolean>;
+        filter: (value: any) => void;
+        getNodeKey: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => any;
+        getNodePath: (data: import("element-plus").TreeKey | TreeNodeData) => TreeNodeData[];
+        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+        getCheckedKeys: (leafOnly?: boolean) => import("element-plus").TreeKey[];
+        getCurrentNode: () => TreeNodeData;
+        getCurrentKey: () => import("element-plus").TreeKey;
+        setCheckedNodes: (nodes: import("element-plus/es/components/tree/src/model/node.mjs").default[], leafOnly?: boolean) => void;
+        setCheckedKeys: (keys: import("element-plus").TreeKey[], leafOnly?: boolean) => void;
+        setChecked: (data: import("element-plus").TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+        getHalfCheckedNodes: () => TreeNodeData[];
+        getHalfCheckedKeys: () => import("element-plus").TreeKey[];
+        setCurrentNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, shouldAutoExpandParent?: boolean) => void;
+        setCurrentKey: (key?: import("element-plus").TreeKey, shouldAutoExpandParent?: boolean) => void;
+        t: import("element-plus").Translator;
+        getNode: (data: import("element-plus").TreeKey | TreeNodeData) => import("element-plus/es/components/tree/src/model/node.mjs").default;
+        remove: (data: TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        append: (data: TreeNodeData, parentNode: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        insertBefore: (data: TreeNodeData, refNode: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        insertAfter: (data: TreeNodeData, refNode: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        handleNodeExpand: (nodeData: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default, instance: import("vue").ComponentInternalInstance) => void;
+        updateKeyChildren: (key: import("element-plus").TreeKey, data: import("element-plus").TreeData) => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
+        'current-change': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean;
+        'node-click': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance, evt: MouseEvent) => any;
+        'node-contextmenu': (evt: Event, data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        'node-collapse': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        'node-expand': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        check: (data: any, checkedInfo: import("element-plus").CheckedInfo) => any;
+        'node-drag-start': (node: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+        'node-drag-end': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: import("element-plus").NodeDropType, evt: DragEvent) => DragEvent;
+        'node-drop': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: "before" | "after" | "inner", evt: DragEvent) => DragEvent;
+        'node-drag-leave': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, oldDropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+        'node-drag-enter': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+        'node-drag-over': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<import("element-plus").TreeData>;
+            default: () => never[];
+        };
+        emptyText: {
+            type: StringConstructor;
+        };
+        renderAfterExpand: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nodeKey: StringConstructor;
+        checkStrictly: BooleanConstructor;
+        defaultExpandAll: BooleanConstructor;
+        expandOnClickNode: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkOnClickNode: BooleanConstructor;
+        checkOnClickLeaf: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkDescendants: BooleanConstructor;
+        autoExpandParent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        defaultCheckedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        defaultExpandedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        currentNodeKey: import("vue").PropType<string | number>;
+        renderContent: {
+            type: import("vue").PropType<import("element-plus").RenderContentFunction>;
+        };
+        showCheckbox: BooleanConstructor;
+        draggable: BooleanConstructor;
+        allowDrag: {
+            type: import("vue").PropType<import("element-plus").AllowDragFunction>;
+        };
+        allowDrop: {
+            type: import("vue").PropType<import("element-plus").AllowDropFunction>;
+        };
+        props: {
+            type: import("vue").PropType<import("element-plus").TreeOptionProps>;
+            default: () => {
+                children: string;
+                label: string;
+                disabled: string;
+            };
+        };
+        lazy: BooleanConstructor;
+        highlightCurrent: BooleanConstructor;
+        load: import("vue").PropType<import("element-plus").LoadFunction>;
+        filterNodeMethod: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
+        accordion: BooleanConstructor;
+        indent: {
+            type: NumberConstructor;
+            default: number;
+        };
+        icon: {
+            type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>>;
+        };
+    }>> & {
+        "onCurrent-change"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => any;
+        "onNode-expand"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        onCheck?: (data: any, checkedInfo: import("element-plus").CheckedInfo) => any;
+        "onCheck-change"?: (data: any, checked: boolean, indeterminate: boolean) => any;
+        "onNode-click"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance, evt: MouseEvent) => any;
+        "onNode-contextmenu"?: (evt: Event, data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        "onNode-collapse"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        "onNode-drag-start"?: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+        "onNode-drag-end"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: import("element-plus").NodeDropType, evt: DragEvent) => any;
+        "onNode-drop"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: "before" | "after" | "inner", evt: DragEvent) => any;
+        "onNode-drag-leave"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, oldDropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+        "onNode-drag-enter"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+        "onNode-drag-over"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+    }, {
+        data: import("element-plus").TreeData;
+        props: import("element-plus").TreeOptionProps;
+        lazy: boolean;
+        draggable: boolean;
+        checkStrictly: boolean;
+        checkOnClickNode: boolean;
+        checkOnClickLeaf: boolean;
+        accordion: boolean;
+        defaultExpandAll: boolean;
+        indent: number;
+        autoExpandParent: boolean;
+        checkDescendants: boolean;
+        renderAfterExpand: boolean;
+        showCheckbox: boolean;
+        expandOnClickNode: boolean;
+        highlightCurrent: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>, import("element-plus/es/utils/index.mjs").SFCWithInstall<import("vue").DefineComponent<{
+        data: {
+            type: import("vue").PropType<import("element-plus").TreeData>;
+            default: () => never[];
+        };
+        emptyText: {
+            type: StringConstructor;
+        };
+        renderAfterExpand: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nodeKey: StringConstructor;
+        checkStrictly: BooleanConstructor;
+        defaultExpandAll: BooleanConstructor;
+        expandOnClickNode: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkOnClickNode: BooleanConstructor;
+        checkOnClickLeaf: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkDescendants: BooleanConstructor;
+        autoExpandParent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        defaultCheckedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        defaultExpandedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        currentNodeKey: import("vue").PropType<string | number>;
+        renderContent: {
+            type: import("vue").PropType<import("element-plus").RenderContentFunction>;
+        };
+        showCheckbox: BooleanConstructor;
+        draggable: BooleanConstructor;
+        allowDrag: {
+            type: import("vue").PropType<import("element-plus").AllowDragFunction>;
+        };
+        allowDrop: {
+            type: import("vue").PropType<import("element-plus").AllowDropFunction>;
+        };
+        props: {
+            /**
+             * 只显示指定应用下的用户组（不可自选应用）
+             */
+            type: import("vue").PropType<import("element-plus").TreeOptionProps>;
+            default: () => {
+                children: string;
+                label: string;
+                disabled: string;
+            };
+        };
+        lazy: BooleanConstructor;
+        highlightCurrent: BooleanConstructor;
+        load: import("vue").PropType<import("element-plus").LoadFunction>;
+        filterNodeMethod: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
+        accordion: BooleanConstructor;
+        indent: {
+            type: NumberConstructor;
+            default: number;
+        };
+        icon: {
+            type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>>;
+        };
+    }, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        store: import("vue").Ref<{
+            currentNode: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            currentNodeKey: import("element-plus").TreeKey;
+            nodesMap: import("element-plus").TreeStoreNodesMap;
+            root: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean; /**
+                 * 业务类别
+                 */
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("element-plus").LoadFunction;
+            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction;
+            key: import("element-plus").TreeKey;
+            defaultCheckedKeys?: import("element-plus").TreeKey[];
+            checkStrictly: boolean;
+            defaultExpandedKeys?: import("element-plus").TreeKey[];
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string;
+                label?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string);
+                disabled?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                isLeaf?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                class?: (data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string | {
+                    [key: string]: boolean;
+                };
+            };
+            initialize: () => void;
+            filter: (value: any) => void;
+            setData: (newVal: import("element-plus").TreeData) => void;
+            getNode: (data: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            insertBefore: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            remove: (data: TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            append: (data: TreeNodeData, parentData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setDefaultCheckedKey: (newVal: import("element-plus").TreeKey[]) => void;
+            registerNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            deregisterNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => import("element-plus").TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => import("element-plus").TreeKey[];
+            _getAllNodes: () => import("element-plus/es/components/tree/src/model/node.mjs").default[];
+            updateChildren: (key: import("element-plus").TreeKey, data: import("element-plus").TreeData) => void;
+            _setCheckedKeys: (key: import("element-plus").TreeKey, leafOnly: boolean, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: import("element-plus/es/components/tree/src/model/node.mjs").default[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: import("element-plus").TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: import("element-plus").TreeKey[]) => void;
+            setChecked: (data: import("element-plus").TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            setCurrentNode: (currentNode: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setUserCurrentNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: import("element-plus").TreeKey, shouldAutoExpandParent?: boolean) => void;
+        }, {
+            currentNode: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean;
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            currentNodeKey: import("element-plus").TreeKey;
+            nodesMap: import("element-plus").TreeStoreNodesMap;
+            root: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean; /**
+                 * 业务类别
+                 */
+                data: TreeNodeData;
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("element-plus").TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any;
+                readonly previousSibling: any;
+                contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: () => void, expandParent?: boolean) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                reInitChecked: () => void;
+            };
+            data: TreeNodeData[];
+            lazy: boolean;
+            load?: import("element-plus").LoadFunction;
+            filterNodeMethod?: import("element-plus").FilterNodeMethodFunction;
+            key: import("element-plus").TreeKey;
+            defaultCheckedKeys?: import("element-plus").TreeKey[];
+            checkStrictly: boolean;
+            defaultExpandedKeys?: import("element-plus").TreeKey[];
+            autoExpandParent: boolean;
+            defaultExpandAll: boolean;
+            checkDescendants: boolean;
+            props: {
+                children?: string;
+                label?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string);
+                disabled?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                isLeaf?: string | ((data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean);
+                class?: (data: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => string | {
+                    [key: string]: boolean;
+                };
+            };
+            initialize: () => void;
+            filter: (value: any) => void;
+            setData: (newVal: import("element-plus").TreeData) => void;
+            getNode: (data: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            insertBefore: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (data: TreeNodeData, refData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            remove: (data: TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            append: (data: TreeNodeData, parentData: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            _initDefaultCheckedNodes: () => void;
+            _initDefaultCheckedNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setDefaultCheckedKey: (newVal: import("element-plus").TreeKey[]) => void;
+            registerNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            deregisterNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+            getCheckedKeys: (leafOnly?: boolean) => import("element-plus").TreeKey[];
+            getHalfCheckedNodes: () => TreeNodeData[];
+            getHalfCheckedKeys: () => import("element-plus").TreeKey[];
+            _getAllNodes: () => import("element-plus/es/components/tree/src/model/node.mjs").default[];
+            updateChildren: (key: import("element-plus").TreeKey, data: import("element-plus").TreeData) => void;
+            _setCheckedKeys: (key: import("element-plus").TreeKey, leafOnly: boolean, checkedKeys: {
+                [key: string]: boolean;
+            }) => void;
+            setCheckedNodes: (array: import("element-plus/es/components/tree/src/model/node.mjs").default[], leafOnly?: boolean) => void;
+            setCheckedKeys: (keys: import("element-plus").TreeKey[], leafOnly?: boolean) => void;
+            setDefaultExpandedKeys: (keys: import("element-plus").TreeKey[]) => void;
+            setChecked: (data: import("element-plus").TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+            getCurrentNode: () => import("element-plus/es/components/tree/src/model/node.mjs").default;
+            setCurrentNode: (currentNode: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            setUserCurrentNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, shouldAutoExpandParent?: boolean) => void;
+            setCurrentNodeKey: (key: import("element-plus").TreeKey, shouldAutoExpandParent?: boolean) => void;
+        }>;
+        root: import("vue").Ref<{
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }, {
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }>;
+        currentNode: import("vue").Ref<{
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }, {
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: TreeNodeData;
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: import("element-plus").TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any;
+            readonly previousSibling: any;
+            contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+            insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: () => void, expandParent?: boolean) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+            eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+            reInitChecked: () => void;
+        }>;
+        dragState: import("vue").Ref<{
+            allowDrop: boolean;
+            dropType: import("element-plus").NodeDropType;
+            draggingNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+            showDropIndicator: boolean;
+            dropNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+        }, {
+            allowDrop: boolean;
+            dropType: import("element-plus").NodeDropType;
+            draggingNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+            showDropIndicator: boolean;
+            dropNode: {
+                node: {
+                    id: number;
+                    text: string;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean;
+                    isLeaf: boolean;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: import("element-plus").TreeKey;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any;
+                    readonly previousSibling: any;
+                    contains: (target: import("element-plus/es/components/tree/src/model/node.mjs").default, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    insertAfter: (child: import("element-plus/es/components/tree/src/model/node.mjs").default | import("element-plus").FakeNode, ref: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChild: (child: import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+                    removeChildByData: (data: TreeNodeData) => void;
+                    expand: (callback?: () => void, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: import("element-plus").TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => void) => void;
+                    reInitChecked: () => void;
+                };
+                $el?: HTMLElement;
+            };
+        }>;
+        el$: import("vue").Ref<HTMLElement, HTMLElement>;
+        dropIndicator$: import("vue").Ref<HTMLElement, HTMLElement>;
+        isEmpty: import("vue").ComputedRef<boolean>;
+        filter: (value: any) => void;
+        getNodeKey: (node: import("element-plus/es/components/tree/src/model/node.mjs").default) => any;
+        getNodePath: (data: import("element-plus").TreeKey | TreeNodeData) => TreeNodeData[];
+        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+        getCheckedKeys: (leafOnly?: boolean) => import("element-plus").TreeKey[];
+        getCurrentNode: () => TreeNodeData;
+        getCurrentKey: () => import("element-plus").TreeKey;
+        setCheckedNodes: (nodes: import("element-plus/es/components/tree/src/model/node.mjs").default[], leafOnly?: boolean) => void;
+        setCheckedKeys: (keys: import("element-plus").TreeKey[], leafOnly?: boolean) => void;
+        setChecked: (data: import("element-plus").TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+        getHalfCheckedNodes: () => TreeNodeData[];
+        getHalfCheckedKeys: () => import("element-plus").TreeKey[];
+        setCurrentNode: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, shouldAutoExpandParent?: boolean) => void;
+        setCurrentKey: (key?: import("element-plus").TreeKey, shouldAutoExpandParent?: boolean) => void;
+        t: import("element-plus").Translator;
+        getNode: (data: import("element-plus").TreeKey | TreeNodeData) => import("element-plus/es/components/tree/src/model/node.mjs").default;
+        remove: (data: TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        append: (data: TreeNodeData, parentNode: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        insertBefore: (data: TreeNodeData, refNode: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        insertAfter: (data: TreeNodeData, refNode: import("element-plus").TreeKey | TreeNodeData | import("element-plus/es/components/tree/src/model/node.mjs").default) => void;
+        handleNodeExpand: (nodeData: TreeNodeData, node: import("element-plus/es/components/tree/src/model/node.mjs").default, instance: import("vue").ComponentInternalInstance) => void;
+        updateKeyChildren: (key: import("element-plus").TreeKey, data: import("element-plus").TreeData) => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
+        'current-change': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => boolean;
+        'node-click': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance, evt: MouseEvent) => any;
+        'node-contextmenu': (evt: Event, data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        'node-collapse': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        'node-expand': (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        check: (data: any, checkedInfo: import("element-plus").CheckedInfo) => any;
+        'node-drag-start': (node: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+        'node-drag-end': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: import("element-plus").NodeDropType, evt: DragEvent) => DragEvent;
+        'node-drop': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: "before" | "after" | "inner", evt: DragEvent) => DragEvent;
+        'node-drag-leave': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, oldDropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+        'node-drag-enter': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+        'node-drag-over': (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => DragEvent;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<import("element-plus").TreeData>;
+            default: () => never[];
+        };
+        emptyText: {
+            type: StringConstructor;
+        };
+        renderAfterExpand: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nodeKey: StringConstructor;
+        checkStrictly: BooleanConstructor;
+        defaultExpandAll: BooleanConstructor;
+        expandOnClickNode: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkOnClickNode: BooleanConstructor;
+        checkOnClickLeaf: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkDescendants: BooleanConstructor;
+        autoExpandParent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        defaultCheckedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        defaultExpandedKeys: import("vue").PropType<import("element-plus").TreeKey[]>;
+        currentNodeKey: import("vue").PropType<string | number>;
+        renderContent: {
+            type: import("vue").PropType<import("element-plus").RenderContentFunction>;
+        };
+        showCheckbox: BooleanConstructor;
+        draggable: BooleanConstructor;
+        allowDrag: {
+            type: import("vue").PropType<import("element-plus").AllowDragFunction>;
+        };
+        allowDrop: {
+            type: import("vue").PropType<import("element-plus").AllowDropFunction>;
+        };
+        props: {
+            type: import("vue").PropType<import("element-plus").TreeOptionProps>;
+            default: () => {
+                children: string;
+                label: string;
+                disabled: string;
+            };
+        };
+        lazy: BooleanConstructor;
+        highlightCurrent: BooleanConstructor;
+        load: import("vue").PropType<import("element-plus").LoadFunction>;
+        filterNodeMethod: import("vue").PropType<import("element-plus").FilterNodeMethodFunction>;
+        accordion: BooleanConstructor;
+        indent: {
+            type: NumberConstructor;
+            default: number;
+        };
+        icon: {
+            type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>>;
+        };
+    }>> & {
+        "onCurrent-change"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default) => any;
+        "onNode-expand"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        onCheck?: (data: any, checkedInfo: import("element-plus").CheckedInfo) => any;
+        "onCheck-change"?: (data: any, checked: boolean, indeterminate: boolean) => any;
+        "onNode-click"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance, evt: MouseEvent) => any;
+        "onNode-contextmenu"?: (evt: Event, data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        "onNode-collapse"?: (data: any, node: import("element-plus/es/components/tree/src/model/node.mjs").default, nodeInstance: import("vue").ComponentInternalInstance) => any;
+        "onNode-drag-start"?: (node: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+        "onNode-drag-end"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: import("element-plus").NodeDropType, evt: DragEvent) => any;
+        "onNode-drop"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropType: "before" | "after" | "inner", evt: DragEvent) => any;
+        "onNode-drag-leave"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, oldDropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+        "onNode-drag-enter"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+        "onNode-drag-over"?: (draggingNode: import("element-plus/es/components/tree/src/model/node.mjs").default, dropNode: import("element-plus/es/components/tree/src/model/node.mjs").default, evt: DragEvent) => any;
+    }, {
+        data: import("element-plus").TreeData;
+        props: import("element-plus").TreeOptionProps;
+        lazy: boolean;
+        draggable: boolean;
+        checkStrictly: boolean;
+        checkOnClickNode: boolean;
+        checkOnClickLeaf: boolean;
+        accordion: boolean;
+        defaultExpandAll: boolean;
+        indent: number;
+        autoExpandParent: boolean;
+        checkDescendants: boolean;
+        renderAfterExpand: boolean;
+        showCheckbox: boolean;
+        expandOnClickNode: boolean;
+        highlightCurrent: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    loaded: (...args: any[]) => void;
+    "update:modelValue": (value: Group) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: Group) => any;
+    onChange?: (...args: any[]) => any;
+    onLoaded?: (...args: any[]) => any;
+}>, {
+    nodeHeight: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=userGroupTree.vue.d.ts.map