maxzhao

/**
   * Whether allow clear
   * @default false
   * @type boolean
   */
  allowClear: boolean;

  defaultValue: TreeNodeValue;

  /**
   * Disabled or not
   * @default false
   * @type boolean
   */
  disabled: boolean;

  /**
   * className of dropdown menu
   * @type string
   */
  dropdownClassName: string;

  /**
   * Determine whether the dropdown menu and the select input are the same width
   * @default true
   * @type boolean
   */
  dropdownMatchSelectWidth: boolean;

  /**
   * To set the style of the dropdown menu
   * @type object
   */
  dropdownStyle: object;

  /**
   * Whether to filter treeNodes by input value. The value of treeNodeFilterProp is used for filtering by default.
   * @default Function
   * @type boolean | Function
   */
  filterTreeNode: boolean | Function;

  /**
   * To set the container of the dropdown menu.
   * The default is to create a div element in body, you can reset it to the scrolling area and make a relative reposition.
   * @default () => document.body
   * @type Function
   */
  getPopupContainer: (triggerNode: any) => HTMLElement;

  /**
   * whether to embed label in value, turn the format of value from string to {value: string, label: VNode, halfChecked: string[]}
   * @default false
   * @type boolean
   */
  labelInValue: boolean;

  /**
   * Load data asynchronously.
   * @type
   */
  loadData: (node: any) => void;

  maxTagCount: number;

  maxTagPlaceholder: any;

  /**
   * Support multiple or not, will be true when enable treeCheckable.
   * @default false
   * @type boolean
   */
  multiple: boolean;

  /**
   * Placeholder of the select input
   * @type any (string | slot)
   */
  placeholder: any;

  /**
   * Placeholder of the search input
   * @type any (string | slot)
   */
  searchPlaceholder: any;

  /**
   * work with `search` event to make search value controlled.
   * @type string
   */
  searchValue: string;

  /**
   * Show Checked Strategy
   * @description The way show selected item in box. Default: just show child nodes.
   * TreeSelect.SHOW_ALL: show all checked treeNodes (include parent treeNode).
   * TreeSelect.SHOW_PARENT: show checked treeNodes (just show parent treeNode).
   * @default TreeSelect.SHOW_CHILD
   * @type
   */
  showCheckedStrategy: 'SHOW_ALL' | 'SHOW_PARENT' | 'SHOW_CHILD';

  /**
   * Whether to display a search input in the dropdown menu(valid only in the single mode)
   * @default false
   * @type boolean
   */
  showSearch: boolean;

  /**
   * To set the size of the select input, options: large small
   * @default 'default'
   * @type string
   */
  size: 'small' | 'large' | 'default';

  /**
   * Whether to show checkbox on the treeNodes
   * @default false
   * @type boolean
   */
  treeCheckable: boolean;

  /**
   * Whether to check nodes precisely (in the checkable mode), means parent and
   * child nodes are not associated, and it will make labelInValue be true
   * @default false
   * @type boolean
   */
  treeCheckStrictly: boolean;

  /**
   * Data of the treeNodes, manual construction work is no longer needed
   * if this property has been set(ensure the Uniqueness of each value)
   * @default []
   * @type object[]
   */
  treeData: TreeData[];

  /**
   * Enable simple mode of treeData.
   * (treeData should like this: [{id:1, pId:0, value:'1', label:"test1",...},...], pId is parent node's id)
   * @default false
   * @type boolean | object[]
   */
  treeDataSimpleMode:
    | boolean
    | Array<{
        id: string;
        pId: string;
        rootPId: any;
      }>;

  /**
   * Whether to expand all treeNodes by default
   * @default false
   * @type boolean
   */
  treeDefaultExpandAll: boolean;

  /**
   * Default expanded treeNodes
   * @type string[] | number[]
   */
  treeDefaultExpandedKeys: string[] | number[];

  /**
   * Set expanded keys
   * @type string[] | number[]
   */
  treeExpandedKeys: string[] | number[];

  /**
   * Will be used for filtering if filterTreeNode returns true
   * @default 'value'
   * @type string
   */
  treeNodeFilterProp: string;

  /**
   * Will render as content of select
   * @default 'title'
   * @type string
   */
  treeNodeLabelProp: string;

  value: TreeNodeValue;

  /**
   * The custom suffix icon
   * @type any (VNode | slot)
   */
  suffixIcon: any;

  removeIcon?: any;

  clearIcon?: any;

  /**
   * remove focus
   */
  blur(): void;

  /**
   * get focus
   */
  focus(): void;

scopedSlots: {title: 'custom'}

export declare class Tree extends AntdComponent {
  static TreeNode: typeof TreeNode;
  static DirectoryTree: typeof DictionaryTree;

  blockNode: boolean;
  selectable: boolean;
  /**
   * treeNode of tree
   * @type TreeNode[]
   */
  treeData: TreeNode[];

  /**
   *
   *@description Replace the title,key and children fields in treeNode with the corresponding fields in treeData
   */
  replaceFields?: {
    /**@default 'children' */
    children?: string;
    /**@default 'title' */
    title?: string;
    /**@default 'key' */
    key?: string;
  };

  /**
   * Whether to automatically expand a parent treeNode
   * @default true
   * @type boolean
   */
  autoExpandParent: boolean;

  /**
   * Adds a Checkbox before the treeNodes
   * @default false
   * @type boolean
   */
  checkable: boolean;

  /**
   * (Controlled) Specifies the keys of the checked treeNodes
   * (PS: When this specifies the key of a treeNode which is also a parent treeNode,
   * all the children treeNodes of will be checked; and vice versa,
   * when it specifies the key of a treeNode which is a child treeNode,
   * its parent treeNode will also be checked. When checkable and checkStrictly is true,
   * its object has checked and halfChecked property. Regardless of whether the child or parent treeNode is checked,
   * they won't impact each other.
   * @default []
   * @type string[] | number[] | { checked: string[]; halfChecked: string[] }
   */
  checkedKeys:
    | string[]
    | number[]
    | {
        checked: string[];
        halfChecked: string[];
      };

  /**
   * Check treeNode precisely; parent treeNode and children treeNodes are not associated
   * @default false
   * @type boolean
   */
  checkStrictly: boolean;

  /**
   * Specifies the keys of the default checked treeNodes
   * @default []
   * @type string[] | number[]
   */
  defaultCheckedKeys: string[] | number[];

  /**
   * Whether to expand all treeNodes by default
   * @default false
   * @type boolean
   */
  defaultExpandAll: boolean;

  /**
   * Specify the keys of the default expanded treeNodes
   * @default []
   * @type string[] | number[]
   */
  defaultExpandedKeys: string[] | number[];

  /**
   * auto expand parent treeNodes when init
   * @default true
   * @type boolean
   */
  defaultExpandParent: boolean;

  /**
   * Specifies the keys of the default selected treeNodes
   * @default []
   * @type string[] | number[]
   */
  defaultSelectedKeys: string[] | number[];

  /**
   * whether disabled the tree
   * @default false
   * @type boolean
   */
  disabled: boolean;

  /**
   * Specifies whether this Tree is draggable (IE > 8)
   * @default false
   * @type boolean
   */
  draggable: boolean;

  /**
   * (Controlled) Specifies the keys of the expanded treeNodes
   * @default []
   * @type string[] | number[]
   */
  expandedKeys: string[] | number[];

  /**
   * Defines a function to filter (highlight) treeNodes.
   * When the function returns true, the corresponding treeNode will be highlighted
   * @type Function
   */
  filterTreeNode: (node: TreeNode) => any;

  /**
   * Load data asynchronously
   * @type Function
   */
  loadData: (node: TreeNode) => any;

  /**
   * (Controlled) Set loaded tree nodes. Need work with loadData
   * @default []
   * @type string[]
   */
  loadedKeys: string[];

  /**
   * Allows selecting multiple treeNodes
   * @default false
   * @type boolean
   */
  multiple: boolean;

  /**
   * (Controlled) Specifies the keys of the selected treeNodes
   * @type string[] | number[]
   */
  selectedKeys: string[] | number[];

  /**
   * Shows the icon before a TreeNode's title.
   * There is no default style; you must set a custom style for it if set to true
   * @default false
   * @type boolean
   */
  showIcon: boolean;

  /**
   * Shows a connecting line
   * @default false
   * @type boolean
   */
  showLine: boolean;
}

/**
   * Class
   * @description className
   * @type string
   */
  class: string;

  /**
   * Style
   * @description style of tree node
   * @type string | object
   */
  style: string | object;

  /**
   * Disable Checkbox
   * @description Disables the checkbox of the treeNode
   * @default false
   * @type boolean
   */
  disableCheckbox: boolean;

  /**
   * Disabled
   * @description Disabled or not
   * @default false
   * @type boolean
   */
  disabled: boolean;

  /**
   * Icon
   * @description customize icon. When you pass component, whose render will receive full TreeNode props as component props
   * @type any (slot | slot-scope)
   */
  icon: any;rightClick

  /**
   * Is Leaf?
   * @description Leaf node or not
   * @default false
   * @type boolean
   */
  isLeaf: boolean;

  /**
   * Key
   * @description Required property, should be unique in the tree
   * (In tree: Used with (default)ExpandedKeys / (default)CheckedKeys / (default)SelectedKeys)
   * @default internal calculated position of treeNode or undefined
   * @type string | number
   */
  key: string | number;

  /**
   * Selectable
   * @description Set whether the treeNode can be selected
   * @default true
   * @type boolean
   */
  selectable: boolean;

  /**
   * Title
   * @description Content showed on the treeNodes
   * @default '---'
   * @type any (string | slot)
   */
  title: any;

  /**
   * Value
   * @description Will be treated as treeNodeFilterProp by default, should be unique in the tree
   * @default undefined
   * @type string
   */
  value: string;

  /**
   * Slots
   * @description When using treeNodes, you can use this property to configure the properties that support the slot,
   * such as slots: { title: 'XXX'}
   * @type object
   */
  slots: object;

  /**
   * Scoped Slots
   * @description When using treeNodes, you can use this property to configure the properties that support the slot,
   * such as scopedSlots: { title: 'XXX'}
   * @type object
   */
  scopedSlots: object;