sj-miniprogram/merchant-chat-pc/node_modules/element-plus/lib/components/tree/src/tree.vue.d.ts

import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
import { Nullable } from "../../../utils/typescript.js";
import "../../../utils/index.js";
import { Translator } from "../../../hooks/use-locale/index.js";
import "../../../hooks/index.js";
import { Node } from "./model/node.js";
import { AllowDragFunction, AllowDropFunction, CheckedInfo, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentFunction, TreeData, TreeKey, TreeNodeData, TreeNodeLoadedDefaultProps, TreeOptionProps, TreeStoreNodesMap } from "./tree.type.js";
import * as vue from "vue";
import { ComponentInternalInstance } from "vue";

//#region ../../packages/components/tree/src/tree.vue.d.ts
declare const _default: typeof __VLS_export;
declare const __VLS_export: vue.DefineComponent<{
  readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | ((new (...args: any[]) => TreeData) | (() => TreeData))[], unknown, unknown, () => never[], boolean>;
  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))[], 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))[], 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))[], 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;
  }>;
  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;
  }>;
  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>;
  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;
  }>;
  el$: vue.Ref<Nullable<HTMLElement>>;
  dropIndicator$: vue.Ref<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;
}, unknown, {}, {}, 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))[], 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))[], 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))[], 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))[], unknown, unknown>>;
    readonly required: false;
    readonly validator: ((val: unknown) => boolean) | undefined;
    __epPropKey: true;
  };
}>> & {
  "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 props: TreeOptionProps;
  readonly data: TreeData;
  readonly checkStrictly: boolean;
  readonly lazy: 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;
}, {}>;
//#endregion
export { _default };