CPL
/
banboshi_V2
1
0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 1 Вики Activity
版博士V2.0程序
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
61 Комити
5 Гране
6.2 GiB
 
 
 
 
Грана: TongWei
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from 'TongWei'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/element-plus/es/components/tree-v2/index.d.ts

1027 lines
73 KiB
Датотека Пермалинк Blame Историја 

  1. export declare const ElTreeV2: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  2.     readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeData) | (() => import("./src/types").TreeData) | ((new (...args: any[]) => import("./src/types").TreeData) | (() => import("./src/types").TreeData))[], unknown, unknown, () => [], boolean>;

  3.     readonly emptyText: {

  4.         readonly type: import("vue").PropType<string>;

  5.         readonly required: false;

  6.         readonly validator: ((val: unknown) => boolean) | undefined;

  7.         __epPropKey: true;

  8.     };

  9.     readonly height: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;

  10.     readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeOptionProps) | (() => import("./src/types").TreeOptionProps) | ((new (...args: any[]) => import("./src/types").TreeOptionProps) | (() => import("./src/types").TreeOptionProps))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  11.         readonly children: import("./src/virtual-tree").TreeOptionsEnum.CHILDREN;

  12.         readonly label: import("./src/virtual-tree").TreeOptionsEnum.LABEL;

  13.         readonly disabled: import("./src/virtual-tree").TreeOptionsEnum.DISABLED;

  14.         readonly value: import("./src/virtual-tree").TreeOptionsEnum.KEY;

  15.     }>, boolean>;

  16.     readonly highlightCurrent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  17.     readonly showCheckbox: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  18.     readonly defaultCheckedKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]) | ((new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]))[], unknown, unknown, () => [], boolean>;

  19.     readonly checkStrictly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  20.     readonly defaultExpandedKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]) | ((new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]))[], unknown, unknown, () => [], boolean>;

  21.     readonly indent: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;

  22.     readonly itemSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;

  23.     readonly icon: {

  24.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  25.         readonly required: false;

  26.         readonly validator: ((val: unknown) => boolean) | undefined;

  27.         __epPropKey: true;

  28.     };

  29.     readonly expandOnClickNode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  30.     readonly checkOnClickNode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  31.     readonly currentNodeKey: {

  32.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("./src/types").TreeKey & {}) | (() => import("./src/types").TreeKey) | ((new (...args: any[]) => import("./src/types").TreeKey & {}) | (() => import("./src/types").TreeKey))[], unknown, unknown>>;

  33.         readonly required: false;

  34.         readonly validator: ((val: unknown) => boolean) | undefined;

  35.         __epPropKey: true;

  36.     };

  37.     readonly accordion: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  38.     readonly filterMethod: {

  39.         readonly type: import("vue").PropType<import("./src/types").FilterMethod>;

  40.         readonly required: false;

  41.         readonly validator: ((val: unknown) => boolean) | undefined;

  42.         __epPropKey: true;

  43.     };

  44.     readonly perfMode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  45. }, {

  46.     props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  47.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeData) | (() => import("./src/types").TreeData) | ((new (...args: any[]) => import("./src/types").TreeData) | (() => import("./src/types").TreeData))[], unknown, unknown, () => [], boolean>;

  48.         readonly emptyText: {

  49.             readonly type: import("vue").PropType<string>;

  50.             readonly required: false;

  51.             readonly validator: ((val: unknown) => boolean) | undefined;

  52.             __epPropKey: true;

  53.         };

  54.         readonly height: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;

  55.         readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeOptionProps) | (() => import("./src/types").TreeOptionProps) | ((new (...args: any[]) => import("./src/types").TreeOptionProps) | (() => import("./src/types").TreeOptionProps))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  56.             readonly children: import("./src/virtual-tree").TreeOptionsEnum.CHILDREN;

  57.             readonly label: import("./src/virtual-tree").TreeOptionsEnum.LABEL;

  58.             readonly disabled: import("./src/virtual-tree").TreeOptionsEnum.DISABLED;

  59.             readonly value: import("./src/virtual-tree").TreeOptionsEnum.KEY;

  60.         }>, boolean>;

  61.         readonly highlightCurrent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  62.         readonly showCheckbox: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  63.         readonly defaultCheckedKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]) | ((new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]))[], unknown, unknown, () => [], boolean>;

  64.         readonly checkStrictly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  65.         readonly defaultExpandedKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]) | ((new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]))[], unknown, unknown, () => [], boolean>;

  66.         readonly indent: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;

  67.         readonly itemSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;

  68.         readonly icon: {

  69.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  70.             readonly required: false;

  71.             readonly validator: ((val: unknown) => boolean) | undefined;

  72.             __epPropKey: true;

  73.         };

  74.         readonly expandOnClickNode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  75.         readonly checkOnClickNode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  76.         readonly currentNodeKey: {

  77.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("./src/types").TreeKey & {}) | (() => import("./src/types").TreeKey) | ((new (...args: any[]) => import("./src/types").TreeKey & {}) | (() => import("./src/types").TreeKey))[], unknown, unknown>>;

  78.             readonly required: false;

  79.             readonly validator: ((val: unknown) => boolean) | undefined;

  80.             __epPropKey: true;

  81.         };

  82.         readonly accordion: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  83.         readonly filterMethod: {

  84.             readonly type: import("vue").PropType<import("./src/types").FilterMethod>;

  85.             readonly required: false;

  86.             readonly validator: ((val: unknown) => boolean) | undefined;

  87.             __epPropKey: true;

  88.         };

  89.         readonly perfMode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  90.     }>> & {

  91.         "onCurrent-change"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  92.         "onNode-expand"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  93.         onCheck?: ((data: import("../tree/src/tree.type").TreeNodeData, checkedInfo: import("./src/types").CheckedInfo) => any) | undefined;

  94.         "onCheck-change"?: ((data: import("../tree/src/tree.type").TreeNodeData, checked: boolean) => any) | undefined;

  95.         "onNode-click"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode, e: MouseEvent) => any) | undefined;

  96.         "onNode-contextmenu"?: ((event: Event, data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  97.         "onNode-collapse"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  98.     }>>;

  99.     emit: ((event: "current-change", data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => void) & ((event: "node-expand", data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => void) & ((event: "check-change", data: import("../tree/src/tree.type").TreeNodeData, checked: boolean) => void) & ((event: "node-click", data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode, e: MouseEvent) => void) & ((event: "node-contextmenu", event: Event, data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => void) & ((event: "node-collapse", data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => void) & ((event: "check", data: import("../tree/src/tree.type").TreeNodeData, checkedInfo: import("./src/types").CheckedInfo) => void);

  100.     slots: Readonly<{

  101.         [name: string]: import("vue").Slot | undefined;

  102.     }>;

  103.     treeNodeSize: import("vue").ComputedRef<number>;

  104.     t: import("../..").Translator;

  105.     ns: {

  106.         namespace: import("vue").ComputedRef<string>;

  107.         b: (blockSuffix?: string) => string;

  108.         e: (element?: string | undefined) => string;

  109.         m: (modifier?: string | undefined) => string;

  110.         be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  111.         em: (element?: string | undefined, modifier?: string | undefined) => string;

  112.         bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  113.         bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  114.         is: {

  115.             (name: string, state: boolean | undefined): string;

  116.             (name: string): string;

  117.         };

  118.         cssVar: (object: Record<string, string>) => Record<string, string>;

  119.         cssVarName: (name: string) => string;

  120.         cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  121.         cssVarBlockName: (name: string) => string;

  122.     };

  123.     flattenTree: import("vue").ComputedRef<import("./src/types").TreeNode[]>;

  124.     isNotEmpty: import("vue").ComputedRef<boolean>;

  125.     toggleExpand: (node: import("./src/types").TreeNode) => void;

  126.     isExpanded: (node: import("./src/types").TreeNode) => boolean;

  127.     isIndeterminate: (node: import("./src/types").TreeNode) => boolean;

  128.     isChecked: (node: import("./src/types").TreeNode) => boolean;

  129.     isDisabled: (node: import("./src/types").TreeNode) => boolean;

  130.     isCurrent: (node: import("./src/types").TreeNode) => boolean;

  131.     isForceHiddenExpandIcon: (node: import("./src/types").TreeNode) => boolean;

  132.     handleNodeClick: (node: import("./src/types").TreeNode, e: MouseEvent) => void;

  133.     handleNodeCheck: (node: import("./src/types").TreeNode, checked: import("..").CheckboxValueType) => void;

  134.     toggleCheckbox: (node: import("./src/types").TreeNode, isChecked: import("..").CheckboxValueType, nodeClick?: boolean) => void;

  135.     getCurrentNode: () => import("./src/types").TreeNodeData | undefined;

  136.     getCurrentKey: () => import("./src/types").TreeKey | undefined;

  137.     setCurrentKey: (key: import("./src/types").TreeKey) => void;

  138.     getCheckedKeys: (leafOnly?: boolean) => import("./src/types").TreeKey[];

  139.     getCheckedNodes: (leafOnly?: boolean) => import("./src/types").TreeNodeData[];

  140.     getHalfCheckedKeys: () => import("./src/types").TreeKey[];

  141.     getHalfCheckedNodes: () => import("./src/types").TreeNodeData[];

  142.     setChecked: (key: import("./src/types").TreeKey, isChecked: boolean) => void;

  143.     setCheckedKeys: (keys: import("./src/types").TreeKey[]) => void;

  144.     filter: (query: string) => void;

  145.     setData: (data: import("./src/types").TreeData) => void;

  146.     getNode: (data: import("./src/types").TreeNodeData | import("./src/types").TreeKey) => import("./src/types").TreeNode | undefined;

  147.     expandNode: (node: import("./src/types").TreeNode) => void;

  148.     collapseNode: (node: import("./src/types").TreeNode) => void;

  149.     setExpandedKeys: (keys: import("./src/types").TreeKey[]) => void;

  150.     FixedSizeList: import("vue").DefineComponent<{

  151.         readonly className: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  152.         readonly containerElement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | Element) & {}) | (() => string | Element) | ((new (...args: any[]) => (string | Element) & {}) | (() => string | Element))[], unknown, unknown, "div", boolean>;

  153.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | ((new (...args: any[]) => any[]) | (() => any[]))[], unknown, unknown, () => [], boolean>;

  154.         readonly direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;

  155.         readonly height: {

  156.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;

  157.             readonly required: true;

  158.             readonly validator: ((val: unknown) => boolean) | undefined;

  159.             __epPropKey: true;

  160.         };

  161.         readonly innerElement: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;

  162.         readonly style: {

  163.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;

  164.             readonly required: false;

  165.             readonly validator: ((val: unknown) => boolean) | undefined;

  166.             __epPropKey: true;

  167.         };

  168.         readonly useIsScrolling: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  169.         readonly width: {

  170.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;

  171.             readonly required: false;

  172.             readonly validator: ((val: unknown) => boolean) | undefined;

  173.             __epPropKey: true;

  174.         };

  175.         readonly perfMode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  176.         readonly scrollbarAlwaysOn: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  177.         readonly cache: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;

  178.         readonly estimatedItemSize: {

  179.             readonly type: import("vue").PropType<number>;

  180.             readonly required: false;

  181.             readonly validator: ((val: unknown) => boolean) | undefined;

  182.             __epPropKey: true;

  183.         };

  184.         readonly layout: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;

  185.         readonly initScrollOffset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;

  186.         readonly total: {

  187.             readonly type: import("vue").PropType<number>;

  188.             readonly required: true;

  189.             readonly validator: ((val: unknown) => boolean) | undefined;

  190.             __epPropKey: true;

  191.         };

  192.         readonly itemSize: {

  193.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (number | import("..").ItemSize) & {}) | (() => number | import("..").ItemSize) | ((new (...args: any[]) => (number | import("..").ItemSize) & {}) | (() => number | import("..").ItemSize))[], never, never>>;

  194.             readonly required: true;

  195.             readonly validator: ((val: unknown) => boolean) | undefined;

  196.             __epPropKey: true;

  197.         };

  198.     }, {

  199.         ns: {

  200.             namespace: import("vue").ComputedRef<string>;

  201.             b: (blockSuffix?: string) => string;

  202.             e: (element?: string | undefined) => string;

  203.             m: (modifier?: string | undefined) => string;

  204.             be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  205.             em: (element?: string | undefined, modifier?: string | undefined) => string;

  206.             bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  207.             bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  208.             is: {

  209.                 (name: string, state: boolean | undefined): string;

  210.                 (name: string): string;

  211.             };

  212.             cssVar: (object: Record<string, string>) => Record<string, string>;

  213.             cssVarName: (name: string) => string;

  214.             cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  215.             cssVarBlockName: (name: string) => string;

  216.         };

  217.         clientSize: import("vue").ComputedRef<string | number | undefined>;

  218.         estimatedTotalSize: import("vue").ComputedRef<number>;

  219.         windowStyle: import("vue").ComputedRef<(string | import("vue").CSSProperties | import("vue").StyleValue[] | {

  220.             [x: string]: string;

  221.             position: string;

  222.             WebkitOverflowScrolling: string;

  223.             willChange: string;

  224.         } | undefined)[]>;

  225.         windowRef: import("vue").Ref<HTMLElement | undefined>;

  226.         innerRef: import("vue").Ref<HTMLElement | undefined>;

  227.         innerStyle: import("vue").ComputedRef<{

  228.             height: string;

  229.             pointerEvents: string | undefined;

  230.             width: string;

  231.         }>;

  232.         itemsToRender: import("vue").ComputedRef<number[]>;

  233.         scrollbarRef: import("vue").Ref<any>;

  234.         states: import("vue").Ref<{

  235.             isScrolling: boolean;

  236.             scrollDir: string;

  237.             scrollOffset: number;

  238.             updateRequested: boolean;

  239.             isScrollbarDragging: boolean;

  240.             scrollbarAlwaysOn: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  241.         }>;

  242.         getItemStyle: (idx: number) => import("vue").CSSProperties;

  243.         onScroll: (e: Event) => void;

  244.         onScrollbarScroll: (distanceToGo: number, totalSteps: number) => void;

  245.         onWheel: (e: WheelEvent) => void;

  246.         scrollTo: (offset: number) => void;

  247.         scrollToItem: (idx: number, alignment?: import("..").Alignment) => void;

  248.         resetScrollTop: () => void;

  249.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "itemRendered")[], "scroll" | "itemRendered", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  250.         readonly className: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  251.         readonly containerElement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | Element) & {}) | (() => string | Element) | ((new (...args: any[]) => (string | Element) & {}) | (() => string | Element))[], unknown, unknown, "div", boolean>;

  252.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | ((new (...args: any[]) => any[]) | (() => any[]))[], unknown, unknown, () => [], boolean>;

  253.         readonly direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;

  254.         readonly height: {

  255.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;

  256.             readonly required: true;

  257.             readonly validator: ((val: unknown) => boolean) | undefined;

  258.             __epPropKey: true;

  259.         };

  260.         readonly innerElement: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;

  261.         readonly style: {

  262.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;

  263.             readonly required: false;

  264.             readonly validator: ((val: unknown) => boolean) | undefined;

  265.             __epPropKey: true;

  266.         };

  267.         readonly useIsScrolling: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  268.         readonly width: {

  269.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;

  270.             readonly required: false;

  271.             readonly validator: ((val: unknown) => boolean) | undefined;

  272.             __epPropKey: true;

  273.         };

  274.         readonly perfMode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  275.         readonly scrollbarAlwaysOn: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  276.         readonly cache: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;

  277.         readonly estimatedItemSize: {

  278.             readonly type: import("vue").PropType<number>;

  279.             readonly required: false;

  280.             readonly validator: ((val: unknown) => boolean) | undefined;

  281.             __epPropKey: true;

  282.         };

  283.         readonly layout: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;

  284.         readonly initScrollOffset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;

  285.         readonly total: {

  286.             readonly type: import("vue").PropType<number>;

  287.             readonly required: true;

  288.             readonly validator: ((val: unknown) => boolean) | undefined;

  289.             __epPropKey: true;

  290.         };

  291.         readonly itemSize: {

  292.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (number | import("..").ItemSize) & {}) | (() => number | import("..").ItemSize) | ((new (...args: any[]) => (number | import("..").ItemSize) & {}) | (() => number | import("..").ItemSize))[], never, never>>;

  293.             readonly required: true;

  294.             readonly validator: ((val: unknown) => boolean) | undefined;

  295.             __epPropKey: true;

  296.         };

  297.     }>> & {

  298.         onScroll?: ((...args: any[]) => any) | undefined;

  299.         onItemRendered?: ((...args: any[]) => any) | undefined;

  300.     }, {

  301.         readonly className: string;

  302.         readonly layout: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", never>;

  303.         readonly direction: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "ltr" | "rtl", never>;

  304.         readonly data: any[];

  305.         readonly scrollbarAlwaysOn: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  306.         readonly containerElement: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | Element) & {}) | (() => string | Element) | ((new (...args: any[]) => (string | Element) & {}) | (() => string | Element))[], unknown, unknown>;

  307.         readonly innerElement: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, ObjectConstructor], unknown, unknown>;

  308.         readonly useIsScrolling: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  309.         readonly perfMode: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  310.         readonly cache: number;

  311.         readonly initScrollOffset: number;

  312.     }>;

  313.     ElTreeNode: import("vue").DefineComponent<{

  314.         readonly node: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeNode) | (() => import("./src/types").TreeNode) | ((new (...args: any[]) => import("./src/types").TreeNode) | (() => import("./src/types").TreeNode))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  315.             readonly key: -1;

  316.             readonly level: -1;

  317.             readonly data: {};

  318.         }>, boolean>;

  319.         readonly expanded: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  320.         readonly checked: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  321.         readonly indeterminate: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  322.         readonly showCheckbox: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  323.         readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  324.         readonly current: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  325.         readonly hiddenExpandIcon: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  326.         readonly itemSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;

  327.     }, {

  328.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  329.             readonly node: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeNode) | (() => import("./src/types").TreeNode) | ((new (...args: any[]) => import("./src/types").TreeNode) | (() => import("./src/types").TreeNode))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  330.                 readonly key: -1;

  331.                 readonly level: -1;

  332.                 readonly data: {};

  333.             }>, boolean>;

  334.             readonly expanded: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  335.             readonly checked: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  336.             readonly indeterminate: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  337.             readonly showCheckbox: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  338.             readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  339.             readonly current: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  340.             readonly hiddenExpandIcon: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  341.             readonly itemSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;

  342.         }>> & {

  343.             onClick?: ((node: import("./src/types").TreeNode, e: MouseEvent) => any) | undefined;

  344.             onToggle?: ((node: import("./src/types").TreeNode) => any) | undefined;

  345.             onCheck?: ((node: import("./src/types").TreeNode, checked: import("..").CheckboxValueType) => any) | undefined;

  346.         }>>;

  347.         emit: ((event: "click", node: import("./src/types").TreeNode, e: MouseEvent) => void) & ((event: "check", node: import("./src/types").TreeNode, checked: import("..").CheckboxValueType) => void) & ((event: "toggle", node: import("./src/types").TreeNode) => void);

  348.         tree: import("./src/types").TreeContext | undefined;

  349.         ns: {

  350.             namespace: import("vue").ComputedRef<string>;

  351.             b: (blockSuffix?: string) => string;

  352.             e: (element?: string | undefined) => string;

  353.             m: (modifier?: string | undefined) => string;

  354.             be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  355.             em: (element?: string | undefined, modifier?: string | undefined) => string;

  356.             bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  357.             bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  358.             is: {

  359.                 (name: string, state: boolean | undefined): string;

  360.                 (name: string): string;

  361.             };

  362.             cssVar: (object: Record<string, string>) => Record<string, string>;

  363.             cssVarName: (name: string) => string;

  364.             cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  365.             cssVarBlockName: (name: string) => string;

  366.         };

  367.         indent: import("vue").ComputedRef<number>;

  368.         icon: import("vue").ComputedRef<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  369.         handleClick: (e: MouseEvent) => void;

  370.         handleExpandIconClick: () => void;

  371.         handleCheckChange: (value: import("..").CheckboxValueType) => void;

  372.         handleContextMenu: (event: Event) => void;

  373.         ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  374.             readonly size: {

  375.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  376.                 readonly required: false;

  377.                 readonly validator: ((val: unknown) => boolean) | undefined;

  378.                 __epPropKey: true;

  379.             };

  380.             readonly color: {

  381.                 readonly type: import("vue").PropType<string>;

  382.                 readonly required: false;

  383.                 readonly validator: ((val: unknown) => boolean) | undefined;

  384.                 __epPropKey: true;

  385.             };

  386.         }, {

  387.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  388.                 readonly size: {

  389.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  390.                     readonly required: false;

  391.                     readonly validator: ((val: unknown) => boolean) | undefined;

  392.                     __epPropKey: true;

  393.                 };

  394.                 readonly color: {

  395.                     readonly type: import("vue").PropType<string>;

  396.                     readonly required: false;

  397.                     readonly validator: ((val: unknown) => boolean) | undefined;

  398.                     __epPropKey: true;

  399.                 };

  400.             }>> & {

  401.                 [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  402.             }>>;

  403.             ns: {

  404.                 namespace: import("vue").ComputedRef<string>;

  405.                 b: (blockSuffix?: string) => string;

  406.                 e: (element?: string | undefined) => string;

  407.                 m: (modifier?: string | undefined) => string;

  408.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  409.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  410.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  411.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  412.                 is: {

  413.                     (name: string, state: boolean | undefined): string;

  414.                     (name: string): string;

  415.                 };

  416.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  417.                 cssVarName: (name: string) => string;

  418.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  419.                 cssVarBlockName: (name: string) => string;

  420.             };

  421.             style: import("vue").ComputedRef<import("vue").CSSProperties>;

  422.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  423.             readonly size: {

  424.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  425.                 readonly required: false;

  426.                 readonly validator: ((val: unknown) => boolean) | undefined;

  427.                 __epPropKey: true;

  428.             };

  429.             readonly color: {

  430.                 readonly type: import("vue").PropType<string>;

  431.                 readonly required: false;

  432.                 readonly validator: ((val: unknown) => boolean) | undefined;

  433.                 __epPropKey: true;

  434.             };

  435.         }>>, {}>> & Record<string, any>;

  436.         ElCheckbox: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  437.             modelValue: {

  438.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  439.                 default: undefined;

  440.             };

  441.             label: {

  442.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  443.             };

  444.             indeterminate: BooleanConstructor;

  445.             disabled: BooleanConstructor;

  446.             checked: BooleanConstructor;

  447.             name: {

  448.                 type: StringConstructor;

  449.                 default: undefined;

  450.             };

  451.             trueLabel: {

  452.                 type: (NumberConstructor | StringConstructor)[];

  453.                 default: undefined;

  454.             };

  455.             falseLabel: {

  456.                 type: (NumberConstructor | StringConstructor)[];

  457.                 default: undefined;

  458.             };

  459.             id: {

  460.                 type: StringConstructor;

  461.                 default: undefined;

  462.             };

  463.             controls: {

  464.                 type: StringConstructor;

  465.                 default: undefined;

  466.             };

  467.             border: BooleanConstructor;

  468.             size: {

  469.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  470.                 readonly required: false;

  471.                 readonly validator: ((val: unknown) => boolean) | undefined;

  472.                 __epPropKey: true;

  473.             };

  474.             tabindex: (NumberConstructor | StringConstructor)[];

  475.             validateEvent: {

  476.                 type: BooleanConstructor;

  477.                 default: boolean;

  478.             };

  479.         }, {

  480.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  481.                 modelValue: {

  482.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  483.                     default: undefined;

  484.                 };

  485.                 label: {

  486.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  487.                 };

  488.                 indeterminate: BooleanConstructor;

  489.                 disabled: BooleanConstructor;

  490.                 checked: BooleanConstructor;

  491.                 name: {

  492.                     type: StringConstructor;

  493.                     default: undefined;

  494.                 };

  495.                 trueLabel: {

  496.                     type: (NumberConstructor | StringConstructor)[];

  497.                     default: undefined;

  498.                 };

  499.                 falseLabel: {

  500.                     type: (NumberConstructor | StringConstructor)[];

  501.                     default: undefined;

  502.                 };

  503.                 id: {

  504.                     type: StringConstructor;

  505.                     default: undefined;

  506.                 };

  507.                 controls: {

  508.                     type: StringConstructor;

  509.                     default: undefined;

  510.                 };

  511.                 border: BooleanConstructor;

  512.                 size: {

  513.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  514.                     readonly required: false;

  515.                     readonly validator: ((val: unknown) => boolean) | undefined;

  516.                     __epPropKey: true;

  517.                 };

  518.                 tabindex: (NumberConstructor | StringConstructor)[];

  519.                 validateEvent: {

  520.                     type: BooleanConstructor;

  521.                     default: boolean;

  522.                 };

  523.             }>> & {

  524.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  525.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  526.             }>>;

  527.             slots: Readonly<{

  528.                 [name: string]: import("vue").Slot | undefined;

  529.             }>;

  530.             inputId: import("vue").Ref<string | undefined>;

  531.             isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  532.             isChecked: import("vue").ComputedRef<boolean>;

  533.             isDisabled: import("vue").ComputedRef<boolean>;

  534.             isFocused: import("vue").Ref<boolean>;

  535.             checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  536.             hasOwnLabel: import("vue").ComputedRef<boolean>;

  537.             model: import("vue").WritableComputedRef<any>;

  538.             handleChange: (e: Event) => void;

  539.             onClickRoot: (e: MouseEvent) => Promise<void>;

  540.             ns: {

  541.                 namespace: import("vue").ComputedRef<string>;

  542.                 b: (blockSuffix?: string) => string;

  543.                 e: (element?: string | undefined) => string;

  544.                 m: (modifier?: string | undefined) => string;

  545.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  546.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  547.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  548.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  549.                 is: {

  550.                     (name: string, state: boolean | undefined): string;

  551.                     (name: string): string;

  552.                 };

  553.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  554.                 cssVarName: (name: string) => string;

  555.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  556.                 cssVarBlockName: (name: string) => string;

  557.             };

  558.             compKls: import("vue").ComputedRef<string[]>;

  559.             spanKls: import("vue").ComputedRef<string[]>;

  560.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  561.             "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  562.             change: (val: import("..").CheckboxValueType) => boolean;

  563.         }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  564.             modelValue: {

  565.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  566.                 default: undefined;

  567.             };

  568.             label: {

  569.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  570.             };

  571.             indeterminate: BooleanConstructor;

  572.             disabled: BooleanConstructor;

  573.             checked: BooleanConstructor;

  574.             name: {

  575.                 type: StringConstructor;

  576.                 default: undefined;

  577.             };

  578.             trueLabel: {

  579.                 type: (NumberConstructor | StringConstructor)[];

  580.                 default: undefined;

  581.             };

  582.             falseLabel: {

  583.                 type: (NumberConstructor | StringConstructor)[];

  584.                 default: undefined;

  585.             };

  586.             id: {

  587.                 type: StringConstructor;

  588.                 default: undefined;

  589.             };

  590.             controls: {

  591.                 type: StringConstructor;

  592.                 default: undefined;

  593.             };

  594.             border: BooleanConstructor;

  595.             size: {

  596.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  597.                 readonly required: false;

  598.                 readonly validator: ((val: unknown) => boolean) | undefined;

  599.                 __epPropKey: true;

  600.             };

  601.             tabindex: (NumberConstructor | StringConstructor)[];

  602.             validateEvent: {

  603.                 type: BooleanConstructor;

  604.                 default: boolean;

  605.             };

  606.         }>> & {

  607.             onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  608.             "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  609.         }, {

  610.             modelValue: string | number | boolean;

  611.             id: string;

  612.             disabled: boolean;

  613.             name: string;

  614.             validateEvent: boolean;

  615.             border: boolean;

  616.             indeterminate: boolean;

  617.             checked: boolean;

  618.             trueLabel: string | number;

  619.             falseLabel: string | number;

  620.             controls: string;

  621.         }>> & {

  622.             CheckboxButton: import("vue").DefineComponent<{

  623.                 modelValue: {

  624.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  625.                     default: undefined;

  626.                 };

  627.                 label: {

  628.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  629.                 };

  630.                 indeterminate: BooleanConstructor;

  631.                 disabled: BooleanConstructor;

  632.                 checked: BooleanConstructor;

  633.                 name: {

  634.                     type: StringConstructor;

  635.                     default: undefined;

  636.                 };

  637.                 trueLabel: {

  638.                     type: (NumberConstructor | StringConstructor)[];

  639.                     default: undefined;

  640.                 };

  641.                 falseLabel: {

  642.                     type: (NumberConstructor | StringConstructor)[];

  643.                     default: undefined;

  644.                 };

  645.                 id: {

  646.                     type: StringConstructor;

  647.                     default: undefined;

  648.                 };

  649.                 controls: {

  650.                     type: StringConstructor;

  651.                     default: undefined;

  652.                 };

  653.                 border: BooleanConstructor;

  654.                 size: {

  655.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  656.                     readonly required: false;

  657.                     readonly validator: ((val: unknown) => boolean) | undefined;

  658.                     __epPropKey: true;

  659.                 };

  660.                 tabindex: (NumberConstructor | StringConstructor)[];

  661.                 validateEvent: {

  662.                     type: BooleanConstructor;

  663.                     default: boolean;

  664.                 };

  665.             }, {

  666.                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  667.                     modelValue: {

  668.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  669.                         default: undefined;

  670.                     };

  671.                     label: {

  672.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  673.                     };

  674.                     indeterminate: BooleanConstructor;

  675.                     disabled: BooleanConstructor;

  676.                     checked: BooleanConstructor;

  677.                     name: {

  678.                         type: StringConstructor;

  679.                         default: undefined;

  680.                     };

  681.                     trueLabel: {

  682.                         type: (NumberConstructor | StringConstructor)[];

  683.                         default: undefined;

  684.                     };

  685.                     falseLabel: {

  686.                         type: (NumberConstructor | StringConstructor)[];

  687.                         default: undefined;

  688.                     };

  689.                     id: {

  690.                         type: StringConstructor;

  691.                         default: undefined;

  692.                     };

  693.                     controls: {

  694.                         type: StringConstructor;

  695.                         default: undefined;

  696.                     };

  697.                     border: BooleanConstructor;

  698.                     size: {

  699.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  700.                         readonly required: false;

  701.                         readonly validator: ((val: unknown) => boolean) | undefined;

  702.                         __epPropKey: true;

  703.                     };

  704.                     tabindex: (NumberConstructor | StringConstructor)[];

  705.                     validateEvent: {

  706.                         type: BooleanConstructor;

  707.                         default: boolean;

  708.                     };

  709.                 }>> & {

  710.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  711.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  712.                 }>>;

  713.                 slots: Readonly<{

  714.                     [name: string]: import("vue").Slot | undefined;

  715.                 }>;

  716.                 isFocused: import("vue").Ref<boolean>;

  717.                 isChecked: import("vue").ComputedRef<boolean>;

  718.                 isDisabled: import("vue").ComputedRef<boolean>;

  719.                 checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  720.                 model: import("vue").WritableComputedRef<any>;

  721.                 handleChange: (e: Event) => void;

  722.                 checkboxGroup: ({

  723.                     modelValue?: import("vue").WritableComputedRef<any> | undefined;

  724.                     changeEvent?: ((...args: any) => any) | undefined;

  725.                 } & import("vue").ToRefs<Pick<import("..").CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;

  726.                 ns: {

  727.                     namespace: import("vue").ComputedRef<string>;

  728.                     b: (blockSuffix?: string) => string;

  729.                     e: (element?: string | undefined) => string;

  730.                     m: (modifier?: string | undefined) => string;

  731.                     be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  732.                     em: (element?: string | undefined, modifier?: string | undefined) => string;

  733.                     bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  734.                     bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  735.                     is: {

  736.                         (name: string, state: boolean | undefined): string;

  737.                         (name: string): string;

  738.                     };

  739.                     cssVar: (object: Record<string, string>) => Record<string, string>;

  740.                     cssVarName: (name: string) => string;

  741.                     cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  742.                     cssVarBlockName: (name: string) => string;

  743.                 };

  744.                 activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  745.                 labelKls: import("vue").ComputedRef<string[]>;

  746.             }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  747.                 "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  748.                 change: (val: import("..").CheckboxValueType) => boolean;

  749.             }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  750.                 modelValue: {

  751.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  752.                     default: undefined;

  753.                 };

  754.                 label: {

  755.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  756.                 };

  757.                 indeterminate: BooleanConstructor;

  758.                 disabled: BooleanConstructor;

  759.                 checked: BooleanConstructor;

  760.                 name: {

  761.                     type: StringConstructor;

  762.                     default: undefined;

  763.                 };

  764.                 trueLabel: {

  765.                     type: (NumberConstructor | StringConstructor)[];

  766.                     default: undefined;

  767.                 };

  768.                 falseLabel: {

  769.                     type: (NumberConstructor | StringConstructor)[];

  770.                     default: undefined;

  771.                 };

  772.                 id: {

  773.                     type: StringConstructor;

  774.                     default: undefined;

  775.                 };

  776.                 controls: {

  777.                     type: StringConstructor;

  778.                     default: undefined;

  779.                 };

  780.                 border: BooleanConstructor;

  781.                 size: {

  782.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  783.                     readonly required: false;

  784.                     readonly validator: ((val: unknown) => boolean) | undefined;

  785.                     __epPropKey: true;

  786.                 };

  787.                 tabindex: (NumberConstructor | StringConstructor)[];

  788.                 validateEvent: {

  789.                     type: BooleanConstructor;

  790.                     default: boolean;

  791.                 };

  792.             }>> & {

  793.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  794.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  795.             }, {

  796.                 modelValue: string | number | boolean;

  797.                 id: string;

  798.                 disabled: boolean;

  799.                 name: string;

  800.                 validateEvent: boolean;

  801.                 border: boolean;

  802.                 indeterminate: boolean;

  803.                 checked: boolean;

  804.                 trueLabel: string | number;

  805.                 falseLabel: string | number;

  806.                 controls: string;

  807.             }>;

  808.             CheckboxGroup: import("vue").DefineComponent<{

  809.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  810.                 readonly disabled: BooleanConstructor;

  811.                 readonly min: NumberConstructor;

  812.                 readonly max: NumberConstructor;

  813.                 readonly size: {

  814.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  815.                     readonly required: false;

  816.                     readonly validator: ((val: unknown) => boolean) | undefined;

  817.                     __epPropKey: true;

  818.                 };

  819.                 readonly label: StringConstructor;

  820.                 readonly fill: StringConstructor;

  821.                 readonly textColor: StringConstructor;

  822.                 readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  823.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  824.             }, {

  825.                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  826.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  827.                     readonly disabled: BooleanConstructor;

  828.                     readonly min: NumberConstructor;

  829.                     readonly max: NumberConstructor;

  830.                     readonly size: {

  831.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  832.                         readonly required: false;

  833.                         readonly validator: ((val: unknown) => boolean) | undefined;

  834.                         __epPropKey: true;

  835.                     };

  836.                     readonly label: StringConstructor;

  837.                     readonly fill: StringConstructor;

  838.                     readonly textColor: StringConstructor;

  839.                     readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  840.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  841.                 }>> & {

  842.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  843.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  844.                 }>>;

  845.                 emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  846.                 ns: {

  847.                     namespace: import("vue").ComputedRef<string>;

  848.                     b: (blockSuffix?: string) => string;

  849.                     e: (element?: string | undefined) => string;

  850.                     m: (modifier?: string | undefined) => string;

  851.                     be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  852.                     em: (element?: string | undefined, modifier?: string | undefined) => string;

  853.                     bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  854.                     bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  855.                     is: {

  856.                         (name: string, state: boolean | undefined): string;

  857.                         (name: string): string;

  858.                     };

  859.                     cssVar: (object: Record<string, string>) => Record<string, string>;

  860.                     cssVarName: (name: string) => string;

  861.                     cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  862.                     cssVarBlockName: (name: string) => string;

  863.                 };

  864.                 formItem: import("..").FormItemContext | undefined;

  865.                 groupId: import("vue").Ref<string | undefined>;

  866.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  867.                 changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  868.                 modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

  869.             }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  870.                 "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  871.                 change: (val: import("..").CheckboxValueType[]) => boolean;

  872.             }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  873.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  874.                 readonly disabled: BooleanConstructor;

  875.                 readonly min: NumberConstructor;

  876.                 readonly max: NumberConstructor;

  877.                 readonly size: {

  878.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  879.                     readonly required: false;

  880.                     readonly validator: ((val: unknown) => boolean) | undefined;

  881.                     __epPropKey: true;

  882.                 };

  883.                 readonly label: StringConstructor;

  884.                 readonly fill: StringConstructor;

  885.                 readonly textColor: StringConstructor;

  886.                 readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  887.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  888.             }>> & {

  889.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  890.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  891.             }, {

  892.                 readonly modelValue: import("..").CheckboxGroupValueType;

  893.                 readonly disabled: boolean;

  894.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  895.                 readonly tag: string;

  896.             }>;

  897.         };

  898.         ElNodeContent: import("vue").DefineComponent<{

  899.             readonly node: {

  900.                 readonly type: import("vue").PropType<import("./src/types").TreeNode>;

  901.                 readonly required: true;

  902.                 readonly validator: ((val: unknown) => boolean) | undefined;

  903.                 __epPropKey: true;

  904.             };

  905.         }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  906.             [key: string]: any;

  907.         }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  908.             [key: string]: any;

  909.         }>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  910.             readonly node: {

  911.                 readonly type: import("vue").PropType<import("./src/types").TreeNode>;

  912.                 readonly required: true;

  913.                 readonly validator: ((val: unknown) => boolean) | undefined;

  914.                 __epPropKey: true;

  915.             };

  916.         }>>, {}>;

  917.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  918.         click: (node: import("./src/types").TreeNode, e: MouseEvent) => boolean;

  919.         toggle: (node: import("./src/types").TreeNode) => boolean;

  920.         check: (node: import("./src/types").TreeNode, checked: import("..").CheckboxValueType) => boolean;

  921.     }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  922.         readonly node: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeNode) | (() => import("./src/types").TreeNode) | ((new (...args: any[]) => import("./src/types").TreeNode) | (() => import("./src/types").TreeNode))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  923.             readonly key: -1;

  924.             readonly level: -1;

  925.             readonly data: {};

  926.         }>, boolean>;

  927.         readonly expanded: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  928.         readonly checked: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  929.         readonly indeterminate: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  930.         readonly showCheckbox: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  931.         readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  932.         readonly current: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  933.         readonly hiddenExpandIcon: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  934.         readonly itemSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;

  935.     }>> & {

  936.         onClick?: ((node: import("./src/types").TreeNode, e: MouseEvent) => any) | undefined;

  937.         onToggle?: ((node: import("./src/types").TreeNode) => any) | undefined;

  938.         onCheck?: ((node: import("./src/types").TreeNode, checked: import("..").CheckboxValueType) => any) | undefined;

  939.     }, {

  940.         readonly disabled: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  941.         readonly expanded: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  942.         readonly current: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  943.         readonly indeterminate: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  944.         readonly checked: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  945.         readonly node: import("./src/types").TreeNode;

  946.         readonly itemSize: number;

  947.         readonly showCheckbox: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  948.         readonly hiddenExpandIcon: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  949.     }>;

  950. }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  951.     "node-click": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode, e: MouseEvent) => MouseEvent;

  952.     "node-expand": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;

  953.     "node-collapse": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;

  954.     "current-change": (data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;

  955.     check: (data: import("../tree/src/tree.type").TreeNodeData, checkedInfo: import("./src/types").CheckedInfo) => import("./src/types").CheckedInfo;

  956.     "check-change": (data: import("../tree/src/tree.type").TreeNodeData, checked: boolean) => boolean;

  957.     "node-contextmenu": (event: Event, data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => import("./src/types").TreeNode;

  958. }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  959.     readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeData) | (() => import("./src/types").TreeData) | ((new (...args: any[]) => import("./src/types").TreeData) | (() => import("./src/types").TreeData))[], unknown, unknown, () => [], boolean>;

  960.     readonly emptyText: {

  961.         readonly type: import("vue").PropType<string>;

  962.         readonly required: false;

  963.         readonly validator: ((val: unknown) => boolean) | undefined;

  964.         __epPropKey: true;

  965.     };

  966.     readonly height: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;

  967.     readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeOptionProps) | (() => import("./src/types").TreeOptionProps) | ((new (...args: any[]) => import("./src/types").TreeOptionProps) | (() => import("./src/types").TreeOptionProps))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  968.         readonly children: import("./src/virtual-tree").TreeOptionsEnum.CHILDREN;

  969.         readonly label: import("./src/virtual-tree").TreeOptionsEnum.LABEL;

  970.         readonly disabled: import("./src/virtual-tree").TreeOptionsEnum.DISABLED;

  971.         readonly value: import("./src/virtual-tree").TreeOptionsEnum.KEY;

  972.     }>, boolean>;

  973.     readonly highlightCurrent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  974.     readonly showCheckbox: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  975.     readonly defaultCheckedKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]) | ((new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]))[], unknown, unknown, () => [], boolean>;

  976.     readonly checkStrictly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  977.     readonly defaultExpandedKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]) | ((new (...args: any[]) => import("./src/types").TreeKey[]) | (() => import("./src/types").TreeKey[]))[], unknown, unknown, () => [], boolean>;

  978.     readonly indent: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;

  979.     readonly itemSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;

  980.     readonly icon: {

  981.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  982.         readonly required: false;

  983.         readonly validator: ((val: unknown) => boolean) | undefined;

  984.         __epPropKey: true;

  985.     };

  986.     readonly expandOnClickNode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  987.     readonly checkOnClickNode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  988.     readonly currentNodeKey: {

  989.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("./src/types").TreeKey & {}) | (() => import("./src/types").TreeKey) | ((new (...args: any[]) => import("./src/types").TreeKey & {}) | (() => import("./src/types").TreeKey))[], unknown, unknown>>;

  990.         readonly required: false;

  991.         readonly validator: ((val: unknown) => boolean) | undefined;

  992.         __epPropKey: true;

  993.     };

  994.     readonly accordion: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  995.     readonly filterMethod: {

  996.         readonly type: import("vue").PropType<import("./src/types").FilterMethod>;

  997.         readonly required: false;

  998.         readonly validator: ((val: unknown) => boolean) | undefined;

  999.         __epPropKey: true;

  1000.     };

  1001.     readonly perfMode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1002. }>> & {

  1003.     "onCurrent-change"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  1004.     "onNode-expand"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  1005.     onCheck?: ((data: import("../tree/src/tree.type").TreeNodeData, checkedInfo: import("./src/types").CheckedInfo) => any) | undefined;

  1006.     "onCheck-change"?: ((data: import("../tree/src/tree.type").TreeNodeData, checked: boolean) => any) | undefined;

  1007.     "onNode-click"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode, e: MouseEvent) => any) | undefined;

  1008.     "onNode-contextmenu"?: ((event: Event, data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  1009.     "onNode-collapse"?: ((data: import("../tree/src/tree.type").TreeNodeData, node: import("./src/types").TreeNode) => any) | undefined;

  1010. }, {

  1011.     readonly props: import("./src/types").TreeOptionProps;

  1012.     readonly height: number;

  1013.     readonly data: import("./src/types").TreeData;

  1014.     readonly checkStrictly: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1015.     readonly accordion: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1016.     readonly indent: number;

  1017.     readonly perfMode: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1018.     readonly itemSize: number;

  1019.     readonly showCheckbox: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1020.     readonly defaultCheckedKeys: import("./src/types").TreeKey[];

  1021.     readonly defaultExpandedKeys: import("./src/types").TreeKey[];

  1022.     readonly expandOnClickNode: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1023.     readonly checkOnClickNode: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1024.     readonly highlightCurrent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1025. }>> & Record<string, any>;

  1026. export default ElTreeV2;