declare function __VLS_template(): { slots: Partial, (_: any) => any>>; refs: { dropdownRef: import('vue').CreateComponentPublicInstanceWithMixins; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: "hover"; }; readonly triggerKeys: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: () => string[]; }; readonly effect: { readonly default: "light"; readonly type: PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; readonly __epPropKey: true; }; readonly type: { readonly type: PropType<"" | "default" | "primary" | "success" | "warning" | "info" | "danger" | "text">; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; }; readonly placement: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: "bottom"; }; readonly popperOptions: { readonly type: globalThis.PropType>; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: () => {}; }; readonly id: StringConstructor; readonly size: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: ""; }; readonly splitButton: BooleanConstructor; readonly hideOnClick: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; readonly loop: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; readonly showTimeout: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: 150; }; readonly hideTimeout: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: 150; }; readonly tabindex: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: 0; }; readonly maxHeight: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: ""; }; readonly popperClass: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: ""; }; readonly disabled: BooleanConstructor; readonly role: { readonly type: globalThis.PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: "menu"; }; readonly buttonProps: { readonly type: PropType>; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; }; readonly teleported: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; readonly persistent: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; }>> & { onClick?: ((...args: any[]) => any) | undefined; "onVisible-change"?: ((...args: any[]) => any) | undefined; onCommand?: ((...args: any[]) => any) | undefined; }, { t: import('element-plus').Translator; ns: { namespace: ComputedRef; b: (blockSuffix?: string) => string; e: (element?: string) => string; m: (modifier?: string) => string; be: (blockSuffix?: string, element?: string) => string; em: (element?: string, modifier?: string) => string; bm: (blockSuffix?: string, modifier?: string) => string; bem: (blockSuffix?: string, element?: string, modifier?: string) => string; is: { (name: string, state: boolean | undefined): string; (name: string): string; }; cssVar: (object: Record) => Record; cssVarName: (name: string) => string; cssVarBlock: (object: Record) => Record; cssVarBlockName: (name: string) => string; }; scrollbar: Ref; wrapStyle: ComputedRef; dropdownTriggerKls: ComputedRef; dropdownSize: ComputedRef<"" | "small" | "default" | "large">; triggerId: ComputedRef; currentTabId: Ref; handleCurrentTabIdChange: (id: string) => void; handlerMainButtonClick: (event: MouseEvent) => void; handleEntryFocus: (e: Event) => void; handleClose: () => void; handleOpen: () => void; handleBeforeShowTooltip: () => void; handleShowTooltip: (event?: Event) => void; handleBeforeHideTooltip: () => void; onFocusAfterTrapped: (e: Event) => void; popperRef: Ref; contentRef: Ref; triggeringElementRef: Ref; referenceElementRef: Ref; }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "visible-change" | "command")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, { readonly disabled: boolean; readonly maxHeight: string | number; readonly size: string; readonly placement: import('element-plus').Placement; readonly effect: import('element-plus').PopperEffect; readonly tabindex: string | number; readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation"; readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]; readonly loop: boolean; readonly popperOptions: Partial; readonly popperClass: string; readonly triggerKeys: string[]; readonly teleported: boolean; readonly persistent: boolean; readonly hideOnClick: boolean; readonly showTimeout: number; readonly hideTimeout: number; readonly splitButton: boolean; }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, { P: {}; B: {}; D: {}; C: {}; M: {}; Defaults: {}; }, Readonly; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: "hover"; }; readonly triggerKeys: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: () => string[]; }; readonly effect: { readonly default: "light"; readonly type: PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; readonly __epPropKey: true; }; readonly type: { readonly type: PropType<"" | "default" | "primary" | "success" | "warning" | "info" | "danger" | "text">; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; }; readonly placement: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: "bottom"; }; readonly popperOptions: { readonly type: globalThis.PropType>; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: () => {}; }; readonly id: StringConstructor; readonly size: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: ""; }; readonly splitButton: BooleanConstructor; readonly hideOnClick: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; readonly loop: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; readonly showTimeout: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: 150; }; readonly hideTimeout: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: 150; }; readonly tabindex: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: 0; }; readonly maxHeight: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: ""; }; readonly popperClass: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: ""; }; readonly disabled: BooleanConstructor; readonly role: { readonly type: globalThis.PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: "menu"; }; readonly buttonProps: { readonly type: PropType>; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; }; readonly teleported: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; readonly persistent: { readonly type: globalThis.PropType; readonly required: false; readonly validator: ((val: unknown) => boolean) | undefined; __epPropKey: true; } & { readonly default: true; }; }>> & { onClick?: ((...args: any[]) => any) | undefined; "onVisible-change"?: ((...args: any[]) => any) | undefined; onCommand?: ((...args: any[]) => any) | undefined; }, { t: import('element-plus').Translator; ns: { namespace: ComputedRef; b: (blockSuffix?: string) => string; e: (element?: string) => string; m: (modifier?: string) => string; be: (blockSuffix?: string, element?: string) => string; em: (element?: string, modifier?: string) => string; bm: (blockSuffix?: string, modifier?: string) => string; bem: (blockSuffix?: string, element?: string, modifier?: string) => string; is: { (name: string, state: boolean | undefined): string; (name: string): string; }; cssVar: (object: Record) => Record; cssVarName: (name: string) => string; cssVarBlock: (object: Record) => Record; cssVarBlockName: (name: string) => string; }; scrollbar: Ref; wrapStyle: ComputedRef; dropdownTriggerKls: ComputedRef; dropdownSize: ComputedRef<"" | "small" | "default" | "large">; triggerId: ComputedRef; currentTabId: Ref; handleCurrentTabIdChange: (id: string) => void; handlerMainButtonClick: (event: MouseEvent) => void; handleEntryFocus: (e: Event) => void; handleClose: () => void; handleOpen: () => void; handleBeforeShowTooltip: () => void; handleShowTooltip: (event?: Event) => void; handleBeforeHideTooltip: () => void; onFocusAfterTrapped: (e: Event) => void; popperRef: Ref; contentRef: Ref; triggeringElementRef: Ref; referenceElementRef: Ref; }, {}, {}, {}, { readonly disabled: boolean; readonly maxHeight: string | number; readonly size: string; readonly placement: import('element-plus').Placement; readonly effect: import('element-plus').PopperEffect; readonly tabindex: string | number; readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation"; readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]; readonly loop: boolean; readonly popperOptions: Partial; readonly popperClass: string; readonly triggerKeys: string[]; readonly teleported: boolean; readonly persistent: boolean; readonly hideOnClick: boolean; readonly showTimeout: number; readonly hideTimeout: number; readonly splitButton: boolean; }> | null; treeRef: import('vue').CreateComponentPublicInstanceWithMixins; 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: PropType; defaultExpandedKeys: PropType; currentNodeKey: PropType; renderContent: { type: PropType; }; showCheckbox: BooleanConstructor; draggable: BooleanConstructor; allowDrag: { type: PropType; }; allowDrop: { type: PropType; }; props: { type: PropType; default: () => { children: string; label: string; disabled: string; }; }; lazy: BooleanConstructor; highlightCurrent: BooleanConstructor; load: PropType; filterNodeMethod: PropType; accordion: BooleanConstructor; indent: { type: NumberConstructor; default: number; }; icon: { type: PropType; }; }>> & { [x: `on${Capitalize}`]: ((...args: any[]) => any) | undefined; }, { ns: { namespace: ComputedRef; b: (blockSuffix?: string) => string; e: (element?: string) => string; m: (modifier?: string) => string; be: (blockSuffix?: string, element?: string) => string; em: (element?: string, modifier?: string) => string; bm: (blockSuffix?: string, modifier?: string) => string; bem: (blockSuffix?: string, element?: string, modifier?: string) => string; is: { (name: string, state: boolean | undefined): string; (name: string): string; }; cssVar: (object: Record) => Record; cssVarName: (name: string) => string; cssVarBlock: (object: Record) => Record; cssVarBlockName: (name: string) => string; }; store: Ref<{ currentNode: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; } | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }; data: import('element-plus').TreeNodeData[]; lazy: boolean; load?: import('element-plus').LoadFunction | undefined; filterNodeMethod?: import('element-plus').FilterNodeMethodFunction | undefined; key: import('element-plus').TreeKey; defaultCheckedKeys?: import('element-plus').TreeKey[] | undefined; checkStrictly: boolean; defaultExpandedKeys?: import('element-plus').TreeKey[] | undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string | undefined; label?: (string | ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => string)) | undefined; disabled?: (string | ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => boolean)) | undefined; isLeaf?: (string | ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => boolean)) | undefined; class?: ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => string | { [key: string]: boolean; }) | undefined; }; initialize: () => void; filter: (value: import('element-plus').FilterValue) => void; setData: (newVal: import('element-plus').TreeData) => void; getNode: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }; insertBefore: (data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; remove: (data: import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; append: (data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; setDefaultCheckedKey: (newVal: import('element-plus').TreeKey[]) => void; registerNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; deregisterNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import('element-plus').TreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => import('element-plus').TreeKey[]; getHalfCheckedNodes: () => import('element-plus').TreeNodeData[]; getHalfCheckedKeys: () => import('element-plus').TreeKey[]; _getAllNodes: () => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }[]; updateChildren: (key: import('element-plus').TreeKey, data: import('element-plus').TreeData) => void; _setCheckedKeys: (key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; } | null; setCurrentNode: (currentNode: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; setUserCurrentNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean) => void; }>; root: Ref<{ id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }>; currentNode: Ref<{ id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; } | null>; dragState: Ref<{ allowDrop: boolean; dropType: import('element-plus').NodeDropType | null; draggingNode: { node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement | undefined; } | null; showDropIndicator: boolean; dropNode: { node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement | undefined; } | null; }>; el$: Ref; dropIndicator$: Ref; isEmpty: ComputedRef; filter: (value: import('element-plus').FilterValue) => void; getNodeKey: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => any; getNodePath: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData) => import('element-plus').TreeNodeData[]; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import('element-plus').TreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => import('element-plus').TreeKey[]; getCurrentNode: () => import('element-plus').TreeNodeData | null; getCurrentKey: () => import('element-plus').TreeKey | null; setCheckedNodes: (nodes: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }[], leafOnly?: boolean) => void; setCheckedKeys: (keys: import('element-plus').TreeKey[], leafOnly?: boolean) => void; setChecked: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData, checked: boolean, deep: boolean) => void; getHalfCheckedNodes: () => import('element-plus').TreeNodeData[]; getHalfCheckedKeys: () => import('element-plus').TreeKey[]; setCurrentNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, shouldAutoExpandParent?: boolean) => void; setCurrentKey: (key?: import('element-plus').TreeKey, shouldAutoExpandParent?: boolean) => void; t: import('element-plus').Translator; getNode: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData) => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }; remove: (data: import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; append: (data: import('element-plus').TreeNodeData, parentNode: import('element-plus').TreeNodeData | import('element-plus').TreeKey | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertBefore: (data: import('element-plus').TreeNodeData, refNode: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (data: import('element-plus').TreeNodeData, refNode: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; handleNodeExpand: (nodeData: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, instance: import('vue').ComponentInternalInstance) => void; updateKeyChildren: (key: import('element-plus').TreeKey, data: import('element-plus').TreeData) => void; }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, string[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, { data: import('element-plus').TreeData; props: import('element-plus').TreeOptionProps; checkStrictly: boolean; lazy: boolean; accordion: boolean; draggable: boolean; defaultExpandAll: boolean; indent: number; autoExpandParent: boolean; checkDescendants: boolean; renderAfterExpand: boolean; showCheckbox: boolean; expandOnClickNode: boolean; checkOnClickNode: boolean; checkOnClickLeaf: boolean; highlightCurrent: boolean; }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, { P: {}; B: {}; D: {}; C: {}; M: {}; Defaults: {}; }, Readonly; 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: PropType; defaultExpandedKeys: PropType; currentNodeKey: PropType; renderContent: { type: PropType; }; showCheckbox: BooleanConstructor; draggable: BooleanConstructor; allowDrag: { type: PropType; }; allowDrop: { type: PropType; }; props: { type: PropType; default: () => { children: string; label: string; disabled: string; }; }; lazy: BooleanConstructor; highlightCurrent: BooleanConstructor; load: PropType; filterNodeMethod: PropType; accordion: BooleanConstructor; indent: { type: NumberConstructor; default: number; }; icon: { type: PropType; }; }>> & { [x: `on${Capitalize}`]: ((...args: any[]) => any) | undefined; }, { ns: { namespace: ComputedRef; b: (blockSuffix?: string) => string; e: (element?: string) => string; m: (modifier?: string) => string; be: (blockSuffix?: string, element?: string) => string; em: (element?: string, modifier?: string) => string; bm: (blockSuffix?: string, modifier?: string) => string; bem: (blockSuffix?: string, element?: string, modifier?: string) => string; is: { (name: string, state: boolean | undefined): string; (name: string): string; }; cssVar: (object: Record) => Record; cssVarName: (name: string) => string; cssVarBlock: (object: Record) => Record; cssVarBlockName: (name: string) => string; }; store: Ref<{ currentNode: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; } | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }; data: import('element-plus').TreeNodeData[]; lazy: boolean; load?: import('element-plus').LoadFunction | undefined; filterNodeMethod?: import('element-plus').FilterNodeMethodFunction | undefined; key: import('element-plus').TreeKey; defaultCheckedKeys?: import('element-plus').TreeKey[] | undefined; checkStrictly: boolean; defaultExpandedKeys?: import('element-plus').TreeKey[] | undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string | undefined; label?: (string | ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => string)) | undefined; disabled?: (string | ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => boolean)) | undefined; isLeaf?: (string | ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => boolean)) | undefined; class?: ((data: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => string | { [key: string]: boolean; }) | undefined; }; initialize: () => void; filter: (value: import('element-plus').FilterValue) => void; setData: (newVal: import('element-plus').TreeData) => void; getNode: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }; insertBefore: (data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; remove: (data: import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; append: (data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; setDefaultCheckedKey: (newVal: import('element-plus').TreeKey[]) => void; registerNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; deregisterNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import('element-plus').TreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => import('element-plus').TreeKey[]; getHalfCheckedNodes: () => import('element-plus').TreeNodeData[]; getHalfCheckedKeys: () => import('element-plus').TreeKey[]; _getAllNodes: () => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }[]; updateChildren: (key: import('element-plus').TreeKey, data: import('element-plus').TreeData) => void; _setCheckedKeys: (key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; } | null; setCurrentNode: (currentNode: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; setUserCurrentNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean) => void; }>; root: Ref<{ id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }>; currentNode: Ref<{ id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; } | null>; dragState: Ref<{ allowDrop: boolean; dropType: import('element-plus').NodeDropType | null; draggingNode: { node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement | undefined; } | null; showDropIndicator: boolean; dropNode: { node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; initialize: () => void; setData: (data: import('element-plus').TreeNodeData) => void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, deep?: boolean) => boolean; remove: () => void; insertChild: (child?: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, index?: number, batch?: boolean) => void; insertBefore: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (child: import('element-plus').FakeNode | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, ref: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChild: (child: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; removeChildByData: (data: import('element-plus').TreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement | undefined; } | null; }>; el$: Ref; dropIndicator$: Ref; isEmpty: ComputedRef; filter: (value: import('element-plus').FilterValue) => void; getNodeKey: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => any; getNodePath: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData) => import('element-plus').TreeNodeData[]; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import('element-plus').TreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => import('element-plus').TreeKey[]; getCurrentNode: () => import('element-plus').TreeNodeData | null; getCurrentKey: () => import('element-plus').TreeKey | null; setCheckedNodes: (nodes: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }[], leafOnly?: boolean) => void; setCheckedKeys: (keys: import('element-plus').TreeKey[], leafOnly?: boolean) => void; setChecked: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData, checked: boolean, deep: boolean) => void; getHalfCheckedNodes: () => import('element-plus').TreeNodeData[]; getHalfCheckedKeys: () => import('element-plus').TreeKey[]; setCurrentNode: (node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, shouldAutoExpandParent?: boolean) => void; setCurrentKey: (key?: import('element-plus').TreeKey, shouldAutoExpandParent?: boolean) => void; t: import('element-plus').Translator; getNode: (data: import('element-plus').TreeKey | import('element-plus').TreeNodeData) => { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }; remove: (data: import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; append: (data: import('element-plus').TreeNodeData, parentNode: import('element-plus').TreeNodeData | import('element-plus').TreeKey | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertBefore: (data: import('element-plus').TreeNodeData, refNode: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; insertAfter: (data: import('element-plus').TreeNodeData, refNode: import('element-plus').TreeKey | import('element-plus').TreeNodeData | { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }) => void; handleNodeExpand: (nodeData: import('element-plus').TreeNodeData, node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: import('element-plus').TreeNodeData; expanded: boolean; parent: /*elided*/ any | null; visible: boolean; isCurrent: boolean; store: { currentNode: /*elided*/ any | null; currentNodeKey: import('element-plus').TreeKey | null; nodesMap: import('element-plus').TreeStoreNodesMap; root: /*elided*/ any; data: import('element-plus').TreeData; 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: import('element-plus').TreeOptionProps; initialize(): void; filter(value: import('element-plus').FilterValue): void; setData(newVal: import('element-plus').TreeData): void; getNode(data: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): /*elided*/ any; insertBefore(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; insertAfter(data: import('element-plus').TreeNodeData, refData: import('element-plus').TreeKey | import('element-plus').TreeNodeData | /*elided*/ any): void; remove(data: import('element-plus').TreeNodeData | /*elided*/ any): void; append(data: import('element-plus').TreeNodeData, parentData: import('element-plus').TreeNodeData | import('element-plus').TreeKey | /*elided*/ any): void; _initDefaultCheckedNodes(): void; _initDefaultCheckedNode(node: /*elided*/ any): void; setDefaultCheckedKey(newVal: import('element-plus').TreeKey[]): void; registerNode(node: /*elided*/ any): void; deregisterNode(node: /*elided*/ any): void; getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): import('element-plus').TreeNodeData[]; getCheckedKeys(leafOnly?: boolean): import('element-plus').TreeKey[]; getHalfCheckedNodes(): import('element-plus').TreeNodeData[]; getHalfCheckedKeys(): import('element-plus').TreeKey[]; _getAllNodes(): /*elided*/ any[]; updateChildren(key: import('element-plus').TreeKey, data: import('element-plus').TreeData): void; _setCheckedKeys(key: import('element-plus').TreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }): void; setCheckedNodes(array: /*elided*/ any[], 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 | import('element-plus').TreeNodeData, checked: boolean, deep: boolean): void; getCurrentNode(): /*elided*/ any | null; setCurrentNode(currentNode: /*elided*/ any): void; setUserCurrentNode(node: /*elided*/ any, shouldAutoExpandParent?: boolean): void; setCurrentNodeKey(key: import('element-plus').TreeKey | null, shouldAutoExpandParent?: boolean): void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: /*elided*/ any[]; loading: boolean; initialize(): void; setData(data: import('element-plus').TreeNodeData): void; readonly label: string; readonly key: import('element-plus').TreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: /*elided*/ any | null; readonly previousSibling: /*elided*/ any | null; contains(target: /*elided*/ any, deep?: boolean): boolean; remove(): void; insertChild(child?: import('element-plus').FakeNode | /*elided*/ any, index?: number, batch?: boolean): void; insertBefore(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; insertAfter(child: import('element-plus').FakeNode | /*elided*/ any, ref: /*elided*/ any): void; removeChild(child: /*elided*/ any): void; removeChildByData(data: import('element-plus').TreeNodeData | null): void; expand(callback?: (() => void) | null, expandParent?: boolean): void; doCreateChildren(array: import('element-plus').TreeNodeData[], defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; collapse(): void; shouldLoadData(): boolean; updateLeafState(): void; setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void; getChildren(forceInit?: boolean): import('element-plus').TreeNodeData | import('element-plus').TreeNodeData[] | null; updateChildren(): void; loadData(callback: (data?: import('element-plus').TreeNodeData[]) => void, defaultProps?: import('element-plus').TreeNodeLoadedDefaultProps): void; eachNode(callback: (node: /*elided*/ any) => void): void; reInitChecked(): void; }, instance: import('vue').ComponentInternalInstance) => void; updateKeyChildren: (key: import('element-plus').TreeKey, data: import('element-plus').TreeData) => void; }, {}, {}, {}, { data: import('element-plus').TreeData; props: import('element-plus').TreeOptionProps; checkStrictly: boolean; lazy: boolean; accordion: boolean; draggable: boolean; defaultExpandAll: boolean; indent: number; autoExpandParent: boolean; checkDescendants: boolean; renderAfterExpand: boolean; showCheckbox: boolean; expandOnClickNode: boolean; checkOnClickNode: boolean; checkOnClickLeaf: boolean; highlightCurrent: boolean; }> | null; }; attrs: Partial<{}>; }; type __VLS_TemplateResult = ReturnType; declare const __VLS_component: import('vue').DefineComponent, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, { "node-click": (...args: any[]) => void; }, string, import('vue').PublicProps, Readonly> & Readonly<{ "onNode-click"?: ((...args: any[]) => any) | undefined; }>, { value: string; size: string; width: string; height: string; }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>; declare const _default: __VLS_WithTemplateSlots; export default _default; type __VLS_WithTemplateSlots = T & { new (): { $slots: S; }; };