@element-plus/nightly 0.0.20260312 → 0.0.20260314

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

@@ -1,17 +1,26 @@
+import { SFCWithInstall } from "../../../utils/vue/typescript.js";
 import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
+import { ComponentSize } from "../../../constants/size.js";
 import { Nullable } from "../../../utils/typescript.js";
 import "../../../utils/index.js";
 import { Translator } from "../../../hooks/use-locale/index.js";
 import "../../../hooks/index.js";
+import { CheckboxProps, CheckboxValueType } from "../../checkbox/src/checkbox.js";
+import { _default as _default$1 } from "../../checkbox/src/checkbox-button.vue.js";
+import { _default as _default$2 } from "../../checkbox/src/checkbox-group.vue.js";
+import { IconProps } from "../../icon/src/icon.js";
+import { TreeStore } from "./model/tree-store.js";
 import { Node } from "./model/node.js";
-import { AllowDragFunction, AllowDropFunction, CheckedInfo, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentFunction, TreeData, TreeKey, TreeNodeData, TreeNodeLoadedDefaultProps, TreeOptionProps, TreeStoreNodesMap } from "./tree.type.js";
+import { TreeNode } from "./model/useDragNode.js";
+import { AllowDragFunction, AllowDropFunction, CheckedInfo, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentFunction, RootTreeType, TreeData, TreeKey, TreeNodeData, TreeNodeLoadedDefaultProps, TreeOptionProps, TreeStoreNodesMap } from "./tree.type.js";
+import "../../../index.js";
 import * as vue from "vue";
 import { ComponentInternalInstance } from "vue";
 
 //#region ../../packages/components/tree/src/tree.vue.d.ts
 declare const _default: typeof __VLS_export;
-declare const __VLS_export: vue.DefineComponent<{
-  readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | ((new (...args: any[]) => TreeData) | (() => TreeData))[], unknown, unknown, () => never[], boolean>;
+declare const __VLS_export: vue.DefineComponent<vue.ExtractPropTypes<{
+  readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
   readonly emptyText: {
     readonly type: vue.PropType<string>;
     readonly required: false;
@@ -40,7 +49,7 @@ declare const __VLS_export: vue.DefineComponent<{
     __epPropKey: true;
   };
   readonly currentNodeKey: {
-    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
     readonly required: false;
     readonly validator: ((val: unknown) => boolean) | undefined;
     __epPropKey: true;
@@ -65,7 +74,7 @@ declare const __VLS_export: vue.DefineComponent<{
     readonly validator: ((val: unknown) => boolean) | undefined;
     __epPropKey: true;
   };
-  readonly props: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | ((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps))[], unknown, unknown, () => {
+  readonly props: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | (((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps)) | null)[], unknown, unknown, () => {
     children: string;
     label: string;
     disabled: string;
@@ -87,12 +96,12 @@ declare const __VLS_export: vue.DefineComponent<{
   readonly accordion: BooleanConstructor;
   readonly indent: EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
   readonly icon: {
-    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | ((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component))[], unknown, unknown>>;
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown>>;
     readonly required: false;
     readonly validator: ((val: unknown) => boolean) | undefined;
     __epPropKey: true;
   };
-}, {
+}>, {
   ns: {
     namespace: vue.ComputedRef<string>;
     b: (blockSuffix?: string) => string;
@@ -254,6 +263,149 @@ declare const __VLS_export: vue.DefineComponent<{
     setCurrentNode: (currentNode: Node) => void;
     setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
     setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+  }, TreeStore | {
+    currentNode: {
+      id: number;
+      text: string | null;
+      checked: boolean;
+      indeterminate: boolean;
+      data: TreeNodeData;
+      expanded: boolean;
+      parent: any | null;
+      visible: boolean;
+      isCurrent: boolean;
+      store: any;
+      isLeafByUser: boolean | undefined;
+      isLeaf: boolean | undefined;
+      canFocus: boolean;
+      level: number;
+      loaded: boolean;
+      childNodes: any[];
+      loading: boolean;
+      isEffectivelyChecked: boolean;
+      initialize: () => void;
+      setData: (data: TreeNodeData) => void;
+      readonly label: string;
+      readonly key: TreeKey | null | undefined;
+      readonly disabled: boolean;
+      readonly nextSibling: any | null;
+      readonly previousSibling: any | null;
+      contains: (target: Node, deep?: boolean) => boolean;
+      remove: () => void;
+      insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+      insertBefore: (child: FakeNode | Node, ref: Node) => void;
+      insertAfter: (child: FakeNode | Node, ref: Node) => void;
+      removeChild: (child: Node) => void;
+      removeChildByData: (data: TreeNodeData | null) => void;
+      expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+      doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+      collapse: () => void;
+      shouldLoadData: () => boolean;
+      updateLeafState: () => void;
+      setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+      getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+      updateChildren: () => void;
+      loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+      eachNode: (callback: (node: Node) => void) => void;
+      reInitChecked: () => void;
+    } | null;
+    currentNodeKey: TreeKey | null;
+    nodesMap: TreeStoreNodesMap;
+    root: {
+      id: number;
+      text: string | null;
+      checked: boolean;
+      indeterminate: boolean;
+      data: TreeNodeData;
+      expanded: boolean;
+      parent: any | null;
+      visible: boolean;
+      isCurrent: boolean;
+      store: any;
+      isLeafByUser: boolean | undefined;
+      isLeaf: boolean | undefined;
+      canFocus: boolean;
+      level: number;
+      loaded: boolean;
+      childNodes: any[];
+      loading: boolean;
+      isEffectivelyChecked: boolean;
+      initialize: () => void;
+      setData: (data: TreeNodeData) => void;
+      readonly label: string;
+      readonly key: TreeKey | null | undefined;
+      readonly disabled: boolean;
+      readonly nextSibling: any | null;
+      readonly previousSibling: any | null;
+      contains: (target: Node, deep?: boolean) => boolean;
+      remove: () => void;
+      insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+      insertBefore: (child: FakeNode | Node, ref: Node) => void;
+      insertAfter: (child: FakeNode | Node, ref: Node) => void;
+      removeChild: (child: Node) => void;
+      removeChildByData: (data: TreeNodeData | null) => void;
+      expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+      doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+      collapse: () => void;
+      shouldLoadData: () => boolean;
+      updateLeafState: () => void;
+      setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+      getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+      updateChildren: () => void;
+      loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+      eachNode: (callback: (node: Node) => void) => void;
+      reInitChecked: () => void;
+    };
+    data: TreeNodeData[];
+    lazy: boolean;
+    load?: LoadFunction | undefined;
+    filterNodeMethod?: FilterNodeMethodFunction | undefined;
+    key: TreeKey;
+    defaultCheckedKeys?: TreeKey[] | undefined;
+    checkStrictly: boolean;
+    defaultExpandedKeys?: TreeKey[] | undefined;
+    autoExpandParent: boolean;
+    defaultExpandAll: boolean;
+    checkDescendants: boolean;
+    props: {
+      children?: string | undefined;
+      label?: (string | ((data: TreeNodeData, node: Node) => string)) | undefined;
+      disabled?: (string | ((data: TreeNodeData, node: Node) => boolean)) | undefined;
+      isLeaf?: (string | ((data: TreeNodeData, node: Node) => boolean)) | undefined;
+      class?: ((data: TreeNodeData, node: Node) => string | {
+        [key: string]: boolean;
+      }) | undefined;
+    };
+    initialize: () => void;
+    filter: (value: FilterValue) => void;
+    setData: (newVal: TreeData) => void;
+    getNode: (data: TreeKey | TreeNodeData | Node) => Node;
+    insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+    insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | Node) => void;
+    remove: (data: TreeNodeData | Node) => void;
+    append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node) => void;
+    _initDefaultCheckedNodes: () => void;
+    _initDefaultCheckedNode: (node: Node) => void;
+    setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+    registerNode: (node: Node) => void;
+    deregisterNode: (node: Node) => void;
+    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getHalfCheckedNodes: () => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    _getAllNodes: () => Node[];
+    updateChildren: (key: TreeKey, data: TreeData) => void;
+    _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+      [key: string]: boolean;
+    }) => void;
+    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+    setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+    getCurrentNode: () => Node | null;
+    setCurrentNode: (currentNode: Node) => void;
+    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+    setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
   }>;
   root: vue.Ref<{
     id: number;
@@ -299,6 +451,50 @@ declare const __VLS_export: vue.DefineComponent<{
     loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
     eachNode: (callback: (node: Node) => void) => void;
     reInitChecked: () => void;
+  }, Node | {
+    id: number;
+    text: string | null;
+    checked: boolean;
+    indeterminate: boolean;
+    data: TreeNodeData;
+    expanded: boolean;
+    parent: any | null;
+    visible: boolean;
+    isCurrent: boolean;
+    store: any;
+    isLeafByUser: boolean | undefined;
+    isLeaf: boolean | undefined;
+    canFocus: boolean;
+    level: number;
+    loaded: boolean;
+    childNodes: any[];
+    loading: boolean;
+    isEffectivelyChecked: boolean;
+    initialize: () => void;
+    setData: (data: TreeNodeData) => void;
+    readonly label: string;
+    readonly key: TreeKey | null | undefined;
+    readonly disabled: boolean;
+    readonly nextSibling: any | null;
+    readonly previousSibling: any | null;
+    contains: (target: Node, deep?: boolean) => boolean;
+    remove: () => void;
+    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+    insertAfter: (child: FakeNode | Node, ref: Node) => void;
+    removeChild: (child: Node) => void;
+    removeChildByData: (data: TreeNodeData | null) => void;
+    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+    doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+    collapse: () => void;
+    shouldLoadData: () => boolean;
+    updateLeafState: () => void;
+    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+    updateChildren: () => void;
+    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+    eachNode: (callback: (node: Node) => void) => void;
+    reInitChecked: () => void;
   }>;
   currentNode: vue.Ref<{
     id: number;
@@ -344,6 +540,50 @@ declare const __VLS_export: vue.DefineComponent<{
     loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
     eachNode: (callback: (node: Node) => void) => void;
     reInitChecked: () => void;
+  } | null, Node | {
+    id: number;
+    text: string | null;
+    checked: boolean;
+    indeterminate: boolean;
+    data: TreeNodeData;
+    expanded: boolean;
+    parent: any | null;
+    visible: boolean;
+    isCurrent: boolean;
+    store: any;
+    isLeafByUser: boolean | undefined;
+    isLeaf: boolean | undefined;
+    canFocus: boolean;
+    level: number;
+    loaded: boolean;
+    childNodes: any[];
+    loading: boolean;
+    isEffectivelyChecked: boolean;
+    initialize: () => void;
+    setData: (data: TreeNodeData) => void;
+    readonly label: string;
+    readonly key: TreeKey | null | undefined;
+    readonly disabled: boolean;
+    readonly nextSibling: any | null;
+    readonly previousSibling: any | null;
+    contains: (target: Node, deep?: boolean) => boolean;
+    remove: () => void;
+    insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+    insertBefore: (child: FakeNode | Node, ref: Node) => void;
+    insertAfter: (child: FakeNode | Node, ref: Node) => void;
+    removeChild: (child: Node) => void;
+    removeChildByData: (data: TreeNodeData | null) => void;
+    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+    doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+    collapse: () => void;
+    shouldLoadData: () => boolean;
+    updateLeafState: () => void;
+    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+    updateChildren: () => void;
+    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+    eachNode: (callback: (node: Node) => void) => void;
+    reInitChecked: () => void;
   } | null>;
   dragState: vue.Ref<{
     allowDrop: boolean;
@@ -445,9 +685,115 @@ declare const __VLS_export: vue.DefineComponent<{
       };
       $el?: HTMLElement | undefined;
     } | null;
+  }, {
+    allowDrop: boolean;
+    dropType: NodeDropType | null;
+    draggingNode: TreeNode | null;
+    showDropIndicator: boolean;
+    dropNode: TreeNode | null;
+  } | {
+    allowDrop: boolean;
+    dropType: NodeDropType | null;
+    draggingNode: {
+      node: {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: any;
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: any | null;
+        readonly previousSibling: any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+        insertAfter: (child: FakeNode | Node, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData | null) => void;
+        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+        updateChildren: () => void;
+        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+        eachNode: (callback: (node: Node) => void) => void;
+        reInitChecked: () => void;
+      };
+      $el?: HTMLElement | undefined;
+    } | null;
+    showDropIndicator: boolean;
+    dropNode: {
+      node: {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: any;
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: any | null;
+        readonly previousSibling: any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+        insertBefore: (child: FakeNode | Node, ref: Node) => void;
+        insertAfter: (child: FakeNode | Node, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData | null) => void;
+        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+        updateChildren: () => void;
+        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+        eachNode: (callback: (node: Node) => void) => void;
+        reInitChecked: () => void;
+      };
+      $el?: HTMLElement | undefined;
+    } | null;
   }>;
-  el$: vue.Ref<Nullable<HTMLElement>>;
-  dropIndicator$: vue.Ref<Nullable<HTMLElement>>;
+  el$: vue.Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
+  dropIndicator$: vue.Ref<Nullable<HTMLElement>, Nullable<HTMLElement>>;
   isEmpty: vue.ComputedRef<boolean>;
   filter: (value: FilterValue) => void;
   getNodeKey: (node: Node) => any;
@@ -471,7 +817,7 @@ declare const __VLS_export: vue.DefineComponent<{
   insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | Node) => void;
   handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
   updateKeyChildren: (key: TreeKey, data: TreeData) => void;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
   'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
   'current-change': (data: any | null, node: Node | null) => boolean;
   'node-click': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null, evt: MouseEvent) => any;
@@ -486,7 +832,7 @@ declare const __VLS_export: vue.DefineComponent<{
   'node-drag-enter': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
   'node-drag-over': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
 }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-  readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | ((new (...args: any[]) => TreeData) | (() => TreeData))[], unknown, unknown, () => never[], boolean>;
+  readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
   readonly emptyText: {
     readonly type: vue.PropType<string>;
     readonly required: false;
@@ -515,7 +861,7 @@ declare const __VLS_export: vue.DefineComponent<{
     __epPropKey: true;
   };
   readonly currentNodeKey: {
-    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
     readonly required: false;
     readonly validator: ((val: unknown) => boolean) | undefined;
     __epPropKey: true;
@@ -540,7 +886,7 @@ declare const __VLS_export: vue.DefineComponent<{
     readonly validator: ((val: unknown) => boolean) | undefined;
     __epPropKey: true;
   };
-  readonly props: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | ((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps))[], unknown, unknown, () => {
+  readonly props: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | (((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps)) | null)[], unknown, unknown, () => {
     children: string;
     label: string;
     disabled: string;
@@ -562,12 +908,12 @@ declare const __VLS_export: vue.DefineComponent<{
   readonly accordion: BooleanConstructor;
   readonly indent: EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
   readonly icon: {
-    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | ((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component))[], unknown, unknown>>;
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown>>;
     readonly required: false;
     readonly validator: ((val: unknown) => boolean) | undefined;
     __epPropKey: true;
   };
-}>> & {
+}>> & Readonly<{
   "onCurrent-change"?: ((data: any, node: Node | null) => any) | undefined;
   "onNode-expand"?: ((data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any) | undefined;
   "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
@@ -581,11 +927,11 @@ declare const __VLS_export: vue.DefineComponent<{
   "onNode-drag-leave"?: ((draggingNode: Node, oldDropNode: Node, evt: DragEvent) => any) | undefined;
   "onNode-drag-enter"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
   "onNode-drag-over"?: ((draggingNode: Node, dropNode: Node, evt: DragEvent) => any) | undefined;
-}, {
+}>, {
+  readonly lazy: boolean;
   readonly props: TreeOptionProps;
   readonly data: TreeData;
   readonly checkStrictly: boolean;
-  readonly lazy: boolean;
   readonly checkOnClickNode: boolean;
   readonly checkOnClickLeaf: EpPropMergeType<BooleanConstructor, unknown, unknown>;
   readonly accordion: boolean;
@@ -598,6 +944,231 @@ declare const __VLS_export: vue.DefineComponent<{
   readonly autoExpandParent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
   readonly checkDescendants: boolean;
   readonly highlightCurrent: boolean;
-}, {}>;
+}, {}, {
+  ElTreeNode: vue.DefineComponent<vue.ExtractPropTypes<{
+    node: {
+      type: typeof Node;
+      default: () => {};
+    };
+    props: {
+      type: vue.PropType<TreeOptionProps>;
+      default: () => {};
+    };
+    accordion: BooleanConstructor;
+    renderContent: FunctionConstructor;
+    renderAfterExpand: BooleanConstructor;
+    showCheckbox: BooleanConstructor;
+  }>, {
+    ns: {
+      namespace: vue.ComputedRef<string>;
+      b: (blockSuffix?: string) => string;
+      e: (element?: string) => string;
+      m: (modifier?: string) => string;
+      be: (blockSuffix?: string, element?: string) => string;
+      em: (element?: string, modifier?: string) => string;
+      bm: (blockSuffix?: string, modifier?: string) => string;
+      bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+      is: {
+        (name: string, state: boolean | undefined): string;
+        (name: string): string;
+      };
+      cssVar: (object: Record<string, string>) => Record<string, string>;
+      cssVarName: (name: string) => string;
+      cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+      cssVarBlockName: (name: string) => string;
+    };
+    node$: vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    tree: RootTreeType;
+    expanded: vue.Ref<boolean, boolean>;
+    childNodeRendered: vue.Ref<boolean, boolean>;
+    oldChecked: vue.Ref<boolean | undefined, boolean | undefined>;
+    oldIndeterminate: vue.Ref<boolean | undefined, boolean | undefined>;
+    getNodeKey: (node: Node) => any;
+    getNodeClass: (node: Node) => {
+      [key: string]: boolean;
+    };
+    handleSelectChange: (checked: boolean, indeterminate: boolean) => void;
+    handleClick: (e: MouseEvent) => void;
+    handleContextMenu: (event: Event) => void;
+    handleExpandIconClick: () => void;
+    handleCheckChange: (value: CheckboxValueType) => void;
+    handleChildNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
+    handleDragStart: (event: DragEvent) => void;
+    handleDragOver: (event: DragEvent) => void;
+    handleDrop: (event: DragEvent) => void;
+    handleDragEnd: (event: DragEvent) => void;
+    CaretRight: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+  }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "node-expand"[], "node-expand", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    node: {
+      type: typeof Node;
+      default: () => {};
+    };
+    props: {
+      type: vue.PropType<TreeOptionProps>;
+      default: () => {};
+    };
+    accordion: BooleanConstructor;
+    renderContent: FunctionConstructor;
+    renderAfterExpand: BooleanConstructor;
+    showCheckbox: BooleanConstructor;
+  }>> & Readonly<{
+    "onNode-expand"?: ((...args: any[]) => any) | undefined;
+  }>, {
+    props: TreeOptionProps;
+    accordion: boolean;
+    node: Node;
+    renderAfterExpand: boolean;
+    showCheckbox: boolean;
+  }, {}, {
+    ElCollapseTransition: SFCWithInstall<{
+      new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {}, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+      }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+      __isFragment?: never;
+      __isTeleport?: never;
+      __isSuspense?: never;
+    } & vue.ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+      $slots: {
+        default?: (props: {}) => any;
+      };
+    })>;
+    ElCheckbox: {
+      new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<CheckboxProps> & Readonly<{
+        onChange?: ((val: CheckboxValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+      }>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        change: (val: CheckboxValueType) => void;
+        "update:modelValue": (val: CheckboxValueType) => void;
+      }, vue.PublicProps, {
+        modelValue: number | string | boolean;
+        label: string | boolean | number | object;
+        value: string | boolean | number | object;
+        disabled: boolean;
+        name: string;
+        trueValue: string | number;
+        falseValue: string | number;
+        trueLabel: string | number;
+        falseLabel: string | number;
+        id: string;
+        validateEvent: boolean;
+      }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+      }, Readonly<CheckboxProps> & Readonly<{
+        onChange?: ((val: CheckboxValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+      }>, {}, {}, {}, {}, {
+        modelValue: number | string | boolean;
+        label: string | boolean | number | object;
+        value: string | boolean | number | object;
+        disabled: boolean;
+        name: string;
+        trueValue: string | number;
+        falseValue: string | number;
+        trueLabel: string | number;
+        falseLabel: string | number;
+        id: string;
+        validateEvent: boolean;
+      }>;
+      __isFragment?: never;
+      __isTeleport?: never;
+      __isSuspense?: never;
+    } & vue.ComponentOptionsBase<Readonly<CheckboxProps> & Readonly<{
+      onChange?: ((val: CheckboxValueType) => any) | undefined;
+      "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+      change: (val: CheckboxValueType) => void;
+      "update:modelValue": (val: CheckboxValueType) => void;
+    }, string, {
+      modelValue: number | string | boolean;
+      label: string | boolean | number | object;
+      value: string | boolean | number | object;
+      disabled: boolean;
+      name: string;
+      trueValue: string | number;
+      falseValue: string | number;
+      trueLabel: string | number;
+      falseLabel: string | number;
+      id: string;
+      validateEvent: boolean;
+    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+      $slots: {
+        default?: (props: {}) => any;
+      };
+    }) & vue.ObjectPlugin & {
+      setPropsDefaults: (defaults: Partial<{
+        readonly modelValue?: (number | string | boolean) | undefined;
+        readonly label?: (string | boolean | number | object) | undefined;
+        readonly value?: (string | boolean | number | object) | undefined;
+        readonly indeterminate?: boolean | undefined;
+        readonly disabled?: boolean | undefined;
+        readonly checked?: boolean | undefined;
+        readonly name?: string | undefined;
+        readonly trueValue?: (string | number) | undefined;
+        readonly falseValue?: (string | number) | undefined;
+        readonly trueLabel?: (string | number) | undefined;
+        readonly falseLabel?: (string | number) | undefined;
+        readonly id?: string | undefined;
+        readonly border?: boolean | undefined;
+        readonly size?: ComponentSize | undefined;
+        readonly tabindex?: (string | number) | undefined;
+        readonly validateEvent?: boolean | undefined;
+        readonly ariaLabel?: string | undefined;
+        readonly ariaControls?: string | undefined;
+        readonly onChange?: ((val: CheckboxValueType) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+      } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps>) => void;
+    } & {
+      CheckboxButton: typeof _default$1;
+      CheckboxGroup: typeof _default$2;
+    };
+    NodeContent: vue.DefineComponent<vue.ExtractPropTypes<{
+      node: {
+        type: ObjectConstructor;
+        required: true;
+      };
+      renderContent: FunctionConstructor;
+    }>, () => any, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+      node: {
+        type: ObjectConstructor;
+        required: true;
+      };
+      renderContent: FunctionConstructor;
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+    ElIcon: SFCWithInstall<{
+      new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
+        size: number | string;
+      }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+      }, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, {
+        size: number | string;
+      }>;
+      __isFragment?: never;
+      __isTeleport?: never;
+      __isSuspense?: never;
+    } & vue.ComponentOptionsBase<Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
+      size: number | string;
+    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+      $slots: {
+        default?: (props: {}) => any;
+      };
+    })>;
+    Loading: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+  }, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 //#endregion
 export { _default };