element-plus 1.3.0-beta.3 → 1.3.0-beta.4

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

@@ -0,0 +1,464 @@
+import type Node from './model/node';
+import type { ComponentInternalInstance, PropType, Component } from 'vue';
+import type { Nullable } from 'element-plus/es/utils/types';
+import type { TreeNodeData, TreeKey, TreeData } from './tree.type';
+declare const _default: import("vue").DefineComponent<{
+    data: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    emptyText: {
+        type: StringConstructor;
+    };
+    renderAfterExpand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nodeKey: StringConstructor;
+    checkStrictly: BooleanConstructor;
+    defaultExpandAll: BooleanConstructor;
+    expandOnClickNode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkOnClickNode: BooleanConstructor;
+    checkDescendants: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoExpandParent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultCheckedKeys: PropType<TreeKey[]>;
+    defaultExpandedKeys: PropType<TreeKey[]>;
+    currentNodeKey: PropType<string | number>;
+    renderContent: FunctionConstructor;
+    showCheckbox: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowDrag: FunctionConstructor;
+    allowDrop: FunctionConstructor;
+    props: {
+        type: PropType<import("./tree.type").TreeOptionProps>;
+        default: () => {
+            children: string;
+            label: string;
+            disabled: string;
+        };
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    highlightCurrent: BooleanConstructor;
+    load: PropType<import("./tree.type").LoadFunction>;
+    filterNodeMethod: PropType<import("./tree.type").FilterNodeMethodFunction>;
+    accordion: BooleanConstructor;
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    icon: PropType<string | Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+}, {
+    store: import("vue").Ref<{
+        currentNode: {
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: {
+                [x: string]: any;
+            };
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any | null;
+            readonly previousSibling: any | null;
+            contains: (target: Node, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: Node | import("./tree.type").FakeNode | undefined, index?: number | undefined, batch?: boolean | undefined) => void;
+            insertBefore: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+            insertAfter: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+            removeChild: (child: Node) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: (() => void) | undefined, expandParent?: boolean | undefined) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean | undefined, deep?: boolean | undefined, recursion?: boolean | undefined, passValue?: boolean | undefined) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (node: Node) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        };
+        currentNodeKey: TreeKey;
+        nodesMap: {
+            [x: string]: {
+                id: number;
+                text: string;
+                checked: boolean;
+                indeterminate: boolean;
+                data: {
+                    [x: string]: any;
+                };
+                expanded: boolean;
+                parent: any;
+                visible: boolean;
+                isCurrent: boolean;
+                store: any;
+                isLeafByUser: boolean;
+                isLeaf: boolean;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: any[];
+                loading: boolean;
+                initialize: () => void;
+                setData: (data: TreeNodeData) => void;
+                readonly label: string;
+                readonly key: TreeKey;
+                readonly disabled: boolean;
+                readonly nextSibling: any | null;
+                readonly previousSibling: any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: Node | import("./tree.type").FakeNode | undefined, index?: number | undefined, batch?: boolean | undefined) => void;
+                insertBefore: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+                insertAfter: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: TreeNodeData) => void;
+                expand: (callback?: (() => void) | undefined, expandParent?: boolean | undefined) => void;
+                doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: string | boolean | undefined, deep?: boolean | undefined, recursion?: boolean | undefined, passValue?: boolean | undefined) => void;
+                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+                updateChildren: () => void;
+                loadData: (callback: (node: Node) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            };
+        };
+        root: {
+            id: number;
+            text: string;
+            checked: boolean;
+            indeterminate: boolean;
+            data: {
+                [x: string]: any;
+            };
+            expanded: boolean;
+            parent: any;
+            visible: boolean;
+            isCurrent: boolean;
+            store: any;
+            isLeafByUser: boolean;
+            isLeaf: boolean;
+            canFocus: boolean;
+            level: number;
+            loaded: boolean;
+            childNodes: any[];
+            loading: boolean;
+            initialize: () => void;
+            setData: (data: TreeNodeData) => void;
+            readonly label: string;
+            readonly key: TreeKey;
+            readonly disabled: boolean;
+            readonly nextSibling: any | null;
+            readonly previousSibling: any | null;
+            contains: (target: Node, deep?: boolean) => boolean;
+            remove: () => void;
+            insertChild: (child?: Node | import("./tree.type").FakeNode | undefined, index?: number | undefined, batch?: boolean | undefined) => void;
+            insertBefore: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+            insertAfter: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+            removeChild: (child: Node) => void;
+            removeChildByData: (data: TreeNodeData) => void;
+            expand: (callback?: (() => void) | undefined, expandParent?: boolean | undefined) => void;
+            doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+            collapse: () => void;
+            shouldLoadData: () => boolean;
+            updateLeafState: () => void;
+            setChecked: (value?: string | boolean | undefined, deep?: boolean | undefined, recursion?: boolean | undefined, passValue?: boolean | undefined) => void;
+            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+            updateChildren: () => void;
+            loadData: (callback: (node: Node) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        };
+        data: {
+            [x: string]: any;
+        }[];
+        lazy: boolean;
+        load: import("./tree.type").LoadFunction;
+        filterNodeMethod: import("./tree.type").FilterNodeMethodFunction;
+        key: TreeKey;
+        defaultCheckedKeys: TreeKey[];
+        checkStrictly: boolean;
+        defaultExpandedKeys: TreeKey[];
+        autoExpandParent: boolean;
+        defaultExpandAll: boolean;
+        checkDescendants: boolean;
+        props: {
+            children: string;
+            label: string;
+            disabled: string;
+            isLeaf?: boolean | undefined;
+            class?: ((data: TreeNodeData, node: Node) => string | {
+                [key: string]: boolean;
+            }) | undefined;
+        };
+        initialize: () => void;
+        filter: (value: any) => void;
+        setData: (newVal: TreeData) => void;
+        getNode: (data: TreeNodeData | TreeKey) => Node;
+        insertBefore: (data: TreeNodeData, refData: TreeNodeData | TreeKey) => void;
+        insertAfter: (data: TreeNodeData, refData: TreeNodeData | TreeKey) => void;
+        remove: (data: Node | TreeNodeData) => void;
+        append: (data: TreeNodeData, parentData: Node | TreeNodeData | TreeKey) => 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: TreeNodeData | TreeKey, checked: boolean, deep: boolean) => void;
+        getCurrentNode: () => Node;
+        setCurrentNode: (currentNode: Node) => void;
+        setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+        setCurrentNodeKey: (key: TreeKey, shouldAutoExpandParent?: boolean) => void;
+    }>;
+    root: import("vue").Ref<{
+        id: number;
+        text: string;
+        checked: boolean;
+        indeterminate: boolean;
+        data: {
+            [x: string]: any;
+        };
+        expanded: boolean;
+        parent: any;
+        visible: boolean;
+        isCurrent: boolean;
+        store: any;
+        isLeafByUser: boolean;
+        isLeaf: boolean;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: any[];
+        loading: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey;
+        readonly disabled: boolean;
+        readonly nextSibling: any | null;
+        readonly previousSibling: any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: Node | import("./tree.type").FakeNode | undefined, index?: number | undefined, batch?: boolean | undefined) => void;
+        insertBefore: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+        insertAfter: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData) => void;
+        expand: (callback?: (() => void) | undefined, expandParent?: boolean | undefined) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: string | boolean | undefined, deep?: boolean | undefined, recursion?: boolean | undefined, passValue?: boolean | undefined) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+        updateChildren: () => void;
+        loadData: (callback: (node: Node) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+    }>;
+    currentNode: import("vue").Ref<{
+        id: number;
+        text: string;
+        checked: boolean;
+        indeterminate: boolean;
+        data: {
+            [x: string]: any;
+        };
+        expanded: boolean;
+        parent: any;
+        visible: boolean;
+        isCurrent: boolean;
+        store: any;
+        isLeafByUser: boolean;
+        isLeaf: boolean;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: any[];
+        loading: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey;
+        readonly disabled: boolean;
+        readonly nextSibling: any | null;
+        readonly previousSibling: any | null;
+        contains: (target: Node, deep?: boolean) => boolean;
+        remove: () => void;
+        insertChild: (child?: Node | import("./tree.type").FakeNode | undefined, index?: number | undefined, batch?: boolean | undefined) => void;
+        insertBefore: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+        insertAfter: (child: Node | import("./tree.type").FakeNode, ref: Node) => void;
+        removeChild: (child: Node) => void;
+        removeChildByData: (data: TreeNodeData) => void;
+        expand: (callback?: (() => void) | undefined, expandParent?: boolean | undefined) => void;
+        doCreateChildren: (array: TreeNodeData[], defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+        collapse: () => void;
+        shouldLoadData: () => boolean;
+        updateLeafState: () => void;
+        setChecked: (value?: string | boolean | undefined, deep?: boolean | undefined, recursion?: boolean | undefined, passValue?: boolean | undefined) => void;
+        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[];
+        updateChildren: () => void;
+        loadData: (callback: (node: Node) => void, defaultProps?: import("./tree.type").TreeNodeLoadedDefaultProps) => void;
+    }>;
+    dragState: import("vue").Ref<{
+        showDropIndicator: boolean;
+        draggingNode: null;
+        dropNode: null;
+        allowDrop: boolean;
+        dropType: null;
+    }>;
+    el$: import("vue").Ref<Nullable<HTMLElement>>;
+    dropIndicator$: import("vue").Ref<Nullable<HTMLElement>>;
+    isEmpty: import("vue").ComputedRef<boolean>;
+    filter: (value: any) => void;
+    getNodeKey: (node: Node) => any;
+    getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
+    getCheckedNodes: (leafOnly: boolean, includeHalfChecked: boolean) => TreeNodeData[];
+    getCheckedKeys: (leafOnly: boolean) => TreeKey[];
+    getCurrentNode: () => TreeNodeData;
+    getCurrentKey: () => any;
+    setCheckedNodes: (nodes: Node[], leafOnly: boolean) => void;
+    setCheckedKeys: (keys: any, leafOnly: boolean) => void;
+    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+    getHalfCheckedNodes: () => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+    setCurrentKey: (key: TreeKey, shouldAutoExpandParent?: boolean) => void;
+    t: import("element-plus/es/hooks").Translator;
+    getNode: (data: TreeKey | TreeNodeData) => Node;
+    remove: (data: TreeNodeData | Node) => void;
+    append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void;
+    insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData) => void;
+    insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData) => void;
+    handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
+    updateKeyChildren: (key: TreeKey, data: TreeData) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("current-change" | "node-expand" | "check-change" | "node-click" | "node-contextmenu" | "node-collapse" | "check" | "node-drag-start" | "node-drag-end" | "node-drop" | "node-drag-leave" | "node-drag-enter" | "node-drag-over")[], "current-change" | "node-expand" | "check-change" | "node-click" | "node-contextmenu" | "node-collapse" | "check" | "node-drag-start" | "node-drag-end" | "node-drop" | "node-drag-leave" | "node-drag-enter" | "node-drag-over", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    data?: unknown;
+    emptyText?: unknown;
+    renderAfterExpand?: unknown;
+    nodeKey?: unknown;
+    checkStrictly?: unknown;
+    defaultExpandAll?: unknown;
+    expandOnClickNode?: unknown;
+    checkOnClickNode?: unknown;
+    checkDescendants?: unknown;
+    autoExpandParent?: unknown;
+    defaultCheckedKeys?: unknown;
+    defaultExpandedKeys?: unknown;
+    currentNodeKey?: unknown;
+    renderContent?: unknown;
+    showCheckbox?: unknown;
+    draggable?: unknown;
+    allowDrag?: unknown;
+    allowDrop?: unknown;
+    props?: unknown;
+    lazy?: unknown;
+    highlightCurrent?: unknown;
+    load?: unknown;
+    filterNodeMethod?: unknown;
+    accordion?: unknown;
+    indent?: unknown;
+    icon?: unknown;
+} & {
+    lazy: boolean;
+    props: import("./tree.type").TreeOptionProps;
+    data: unknown[];
+    draggable: boolean;
+    checkStrictly: boolean;
+    accordion: boolean;
+    defaultExpandAll: boolean;
+    indent: number;
+    renderAfterExpand: boolean;
+    showCheckbox: boolean;
+    expandOnClickNode: boolean;
+    checkOnClickNode: boolean;
+    checkDescendants: boolean;
+    autoExpandParent: boolean;
+    highlightCurrent: boolean;
+} & {
+    icon?: string | Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+    load?: import("./tree.type").LoadFunction | undefined;
+    emptyText?: string | undefined;
+    renderContent?: Function | undefined;
+    defaultCheckedKeys?: TreeKey[] | undefined;
+    defaultExpandedKeys?: TreeKey[] | undefined;
+    filterNodeMethod?: import("./tree.type").FilterNodeMethodFunction | undefined;
+    nodeKey?: string | undefined;
+    allowDrag?: Function | undefined;
+    allowDrop?: Function | undefined;
+    currentNodeKey?: string | number | undefined;
+}> & {
+    "onCurrent-change"?: ((...args: any[]) => any) | undefined;
+    "onNode-expand"?: ((...args: any[]) => any) | undefined;
+    onCheck?: ((...args: any[]) => any) | undefined;
+    "onCheck-change"?: ((...args: any[]) => any) | undefined;
+    "onNode-click"?: ((...args: any[]) => any) | undefined;
+    "onNode-contextmenu"?: ((...args: any[]) => any) | undefined;
+    "onNode-collapse"?: ((...args: any[]) => any) | undefined;
+    "onNode-drag-start"?: ((...args: any[]) => any) | undefined;
+    "onNode-drag-end"?: ((...args: any[]) => any) | undefined;
+    "onNode-drop"?: ((...args: any[]) => any) | undefined;
+    "onNode-drag-leave"?: ((...args: any[]) => any) | undefined;
+    "onNode-drag-enter"?: ((...args: any[]) => any) | undefined;
+    "onNode-drag-over"?: ((...args: any[]) => any) | undefined;
+}, {
+    lazy: boolean;
+    props: import("./tree.type").TreeOptionProps;
+    data: unknown[];
+    draggable: boolean;
+    checkStrictly: boolean;
+    accordion: boolean;
+    defaultExpandAll: boolean;
+    indent: number;
+    renderAfterExpand: boolean;
+    showCheckbox: boolean;
+    expandOnClickNode: boolean;
+    checkOnClickNode: boolean;
+    checkDescendants: boolean;
+    autoExpandParent: boolean;
+    highlightCurrent: boolean;
+}>;
+export default _default;

package/es/packages/components/tree/style/css.d.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-tree.css';
+import 'element-plus/es/components/checkbox/style/css';

package/es/packages/components/tree/style/index.d.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/tree.scss';
+import 'element-plus/es/components/checkbox/style/index';

package/es/packages/components/tree-v2/index.d.ts

@@ -0,0 +1,111 @@
+export declare const ElTreeV2: import("../../utils/types").SFCWithInstall<import("vue").DefineComponent<{
+    readonly data: import("../../utils/props").BuildPropReturn<import("../../utils/props").PropWrapper<import("./src/types").TreeData>, () => [], unknown, unknown, unknown>;
+    readonly emptyText: import("../../utils/props").BuildPropReturn<StringConstructor, unknown, unknown, unknown, unknown>;
+    readonly height: import("../../utils/props").BuildPropReturn<NumberConstructor, 200, unknown, unknown, unknown>;
+    readonly props: import("../../utils/props").BuildPropReturn<import("../../utils/props").PropWrapper<import("./src/types").TreeOptionProps>, () => import("../../utils/types").Mutable<{
+        readonly children: import("./src/virtual-tree").TreeOptionsEnum.CHILDREN;
+        readonly label: import("./src/virtual-tree").TreeOptionsEnum.LABEL;
+        readonly disabled: import("./src/virtual-tree").TreeOptionsEnum.DISABLED;
+        readonly value: import("./src/virtual-tree").TreeOptionsEnum.KEY;
+    }>, unknown, unknown, unknown>;
+    readonly highlightCurrent: import("../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly showCheckbox: import("../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly defaultCheckedKeys: import("../../utils/props").BuildPropReturn<import("../../utils/props").PropWrapper<import("./src/types").TreeKey[]>, () => [], unknown, unknown, unknown>;
+    readonly checkStrictly: import("../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly defaultExpandedKeys: import("../../utils/props").BuildPropReturn<import("../../utils/props").PropWrapper<import("./src/types").TreeKey[]>, () => [], unknown, unknown, unknown>;
+    readonly indent: import("../../utils/props").BuildPropReturn<NumberConstructor, 16, unknown, unknown, unknown>;
+    readonly icon: import("../../utils/props").BuildPropReturn<StringConstructor, unknown, unknown, unknown, unknown>;
+    readonly expandOnClickNode: import("../../utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+    readonly checkOnClickNode: import("../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly currentNodeKey: import("../../utils/props").BuildPropReturn<import("../../utils/props").PropWrapper<import("./src/types").TreeKey>, unknown, unknown, unknown, unknown>;
+    readonly accordion: import("../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly filterMethod: import("../../utils/props").BuildPropReturn<import("../../utils/props").PropWrapper<import("./src/types").FilterMethod>, unknown, unknown, unknown, unknown>;
+    readonly perfMode: import("../../utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+}, {
+    t: import("../..").Translator;
+    flattenTree: import("vue").ComputedRef<import("./src/types").TreeNode[]>;
+    itemSize: number;
+    isNotEmpty: import("vue").ComputedRef<boolean>;
+    toggleExpand: (node: import("./src/types").TreeNode) => void;
+    toggleCheckbox: (node: import("./src/types").TreeNode, isChecked: boolean, nodeClick?: boolean) => void;
+    isExpanded: (node: import("./src/types").TreeNode) => boolean;
+    isIndeterminate: (node: import("./src/types").TreeNode) => boolean;
+    isChecked: (node: import("./src/types").TreeNode) => boolean;
+    isDisabled: (node: import("./src/types").TreeNode) => boolean;
+    isCurrent: (node: import("./src/types").TreeNode) => boolean;
+    isForceHiddenExpandIcon: (node: import("./src/types").TreeNode) => boolean;
+    handleNodeClick: (node: import("./src/types").TreeNode) => void;
+    handleNodeCheck: (node: import("./src/types").TreeNode, checked: boolean) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "node-click": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;
+    "node-expand": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;
+    "node-collapse": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;
+    "current-change": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;
+    check: (data: import("../tree/src/tree.type").TreeNodeData, checkedInfo: import("./src/types").CheckedInfo) => import("./src/types").CheckedInfo;
+    "check-change": (data: import("../tree/src/tree.type").TreeNodeData, checked: boolean) => boolean;
+    "node-contextmenu": (event: Event, data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly data?: unknown;
+    readonly emptyText?: unknown;
+    readonly height?: unknown;
+    readonly props?: unknown;
+    readonly highlightCurrent?: unknown;
+    readonly showCheckbox?: unknown;
+    readonly defaultCheckedKeys?: unknown;
+    readonly checkStrictly?: unknown;
+    readonly defaultExpandedKeys?: unknown;
+    readonly indent?: unknown;
+    readonly icon?: unknown;
+    readonly expandOnClickNode?: unknown;
+    readonly checkOnClickNode?: unknown;
+    readonly currentNodeKey?: unknown;
+    readonly accordion?: unknown;
+    readonly filterMethod?: unknown;
+    readonly perfMode?: unknown;
+} & {
+    props: import("./src/types").TreeOptionProps;
+    data: import("./src/types").TreeData;
+    height: number;
+    checkStrictly: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    accordion: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    indent: number;
+    showCheckbox: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    defaultCheckedKeys: import("./src/types").TreeKey[];
+    defaultExpandedKeys: import("./src/types").TreeKey[];
+    expandOnClickNode: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    checkOnClickNode: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    highlightCurrent: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    perfMode: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+} & {
+    icon?: string | undefined;
+    emptyText?: string | undefined;
+    filterMethod?: import("./src/types").FilterMethod | undefined;
+    currentNodeKey?: import("../../utils/props").BuildPropType<import("../../utils/props").PropWrapper<import("./src/types").TreeKey>, unknown, unknown> | undefined;
+}> & {
+    "onCurrent-change"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;
+    "onNode-expand"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;
+    onCheck?: ((data: import("../tree/src/tree.type").TreeNodeData, checkedInfo: import("./src/types").CheckedInfo) => any) | undefined;
+    "onCheck-change"?: ((data: import("../tree/src/tree.type").TreeNodeData, checked: boolean) => any) | undefined;
+    "onNode-click"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;
+    "onNode-contextmenu"?: ((event: Event, data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;
+    "onNode-collapse"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;
+}, {
+    icon: string;
+    props: import("./src/types").TreeOptionProps;
+    data: import("./src/types").TreeData;
+    height: number;
+    emptyText: string;
+    checkStrictly: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    filterMethod: import("./src/types").FilterMethod;
+    accordion: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    indent: number;
+    showCheckbox: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    defaultCheckedKeys: import("./src/types").TreeKey[];
+    defaultExpandedKeys: import("./src/types").TreeKey[];
+    expandOnClickNode: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    checkOnClickNode: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    highlightCurrent: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    currentNodeKey: import("../../utils/props").BuildPropType<import("../../utils/props").PropWrapper<import("./src/types").TreeKey>, unknown, unknown>;
+    perfMode: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+}>> & Record<string, any>;
+export default ElTreeV2;

package/es/packages/components/tree-v2/src/composables/useCheck.d.ts

@@ -0,0 +1,14 @@
+import type { Ref } from 'vue';
+import type { TreeProps, TreeKey, TreeNode, Tree, TreeNodeData } from '../types';
+export declare function useCheck(props: TreeProps, tree: Ref<Tree | undefined>): {
+    updateCheckedKeys: () => void;
+    toggleCheckbox: (node: TreeNode, isChecked: boolean, nodeClick?: boolean) => void;
+    isChecked: (node: TreeNode) => boolean;
+    isIndeterminate: (node: TreeNode) => boolean;
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getCheckedNodes: (leafOnly?: boolean) => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    getHalfCheckedNodes: () => TreeNodeData[];
+    setChecked: (key: TreeKey, isChecked: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[]) => void;
+};

package/es/packages/components/tree-v2/src/composables/useFilter.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+import type { TreeProps, TreeKey, TreeNode, Tree } from '../types';
+export declare function useFilter(props: TreeProps, tree: Ref<Tree | undefined>): {
+    hiddenExpandIconKeySet: Ref<Set<TreeKey>>;
+    hiddenNodeKeySet: Ref<Set<TreeKey>>;
+    doFilter: (query: string) => Set<TreeKey> | undefined;
+    isForceHiddenExpandIcon: (node: TreeNode) => boolean;
+};

package/es/packages/components/tree-v2/src/composables/useTree.d.ts

@@ -0,0 +1,29 @@
+import type { TreeProps, TreeNodeData, TreeKey, TreeNode, TreeData, Tree } from '../types';
+export declare function useTree(props: TreeProps, emit: any): {
+    tree: import("vue").ShallowRef<Tree | undefined>;
+    flattenTree: import("vue").ComputedRef<TreeNode[]>;
+    isNotEmpty: import("vue").ComputedRef<boolean>;
+    getKey: (node: TreeNodeData) => TreeKey;
+    getChildren: (node: TreeNodeData) => TreeNodeData[];
+    toggleExpand: (node: TreeNode) => void;
+    toggleCheckbox: (node: TreeNode, isChecked: boolean, nodeClick?: boolean) => void;
+    isExpanded: (node: TreeNode) => boolean;
+    isChecked: (node: TreeNode) => boolean;
+    isIndeterminate: (node: TreeNode) => boolean;
+    isDisabled: (node: TreeNode) => boolean;
+    isCurrent: (node: TreeNode) => boolean;
+    isForceHiddenExpandIcon: (node: TreeNode) => boolean;
+    handleNodeClick: (node: TreeNode) => void;
+    handleNodeCheck: (node: TreeNode, checked: boolean) => void;
+    getCurrentNode: () => TreeNodeData | undefined;
+    getCurrentKey: () => TreeKey | undefined;
+    setCurrentKey: (key: TreeKey) => void;
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getCheckedNodes: (leafOnly?: boolean) => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    getHalfCheckedNodes: () => TreeNodeData[];
+    setChecked: (key: TreeKey, isChecked: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[]) => void;
+    filter: (query: string) => void;
+    setData: (data: TreeData) => void;
+};

package/es/packages/components/tree-v2/src/tree-node-content.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly node: import("../../../utils/props").BuildPropReturn<import("../../../utils/props").PropWrapper<import("./types").TreeNode>, unknown, true, unknown, unknown>;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly node?: unknown;
+} & {
+    node: import("./types").TreeNode;
+} & {}>, {}>;
+export default _default;