import { SFCWithInstall } from "../../../utils/vue/typescript.js";
import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
import { ComponentSize } from "../../../constants/size.js";
import { Nullable } from "../../../utils/typescript.js";
import "../../../utils/index.js";
import { Translator } from "../../../hooks/use-locale/index.js";
import "../../../hooks/index.js";
import { CheckboxProps, CheckboxValueType } from "../../checkbox/src/checkbox.js";
import { _default as _default$1 } from "../../checkbox/src/checkbox-button.vue.js";
import { _default as _default$2 } from "../../checkbox/src/checkbox-group.vue.js";
import { IconProps } from "../../icon/src/icon.js";
import { TreeStore } from "./model/tree-store.js";
import { Node } from "./model/node.js";
import { TreeNode } from "./model/useDragNode.js";
import { AllowDragFunction, AllowDropFunction, CheckedInfo, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentFunction, RootTreeType, TreeData, TreeKey, TreeNodeData, TreeNodeLoadedDefaultProps, TreeOptionProps, TreeStoreNodesMap } from "./tree.type.js";
import "../../../index.js";
import * as vue from "vue";
import { ComponentInternalInstance } from "vue";

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