import type { CheckboxProps } from '../checkbox';
import type { TNode, TreeOptionData } from '../common';
export interface TdTreeProps<T extends TreeOptionData = TreeOptionData> {
    activable?: boolean;
    actived?: Array<TreeNodeValue>;
    defaultActived?: Array<TreeNodeValue>;
    activeMultiple?: boolean;
    allowFoldNodeOnFilter?: boolean;
    checkable?: boolean;
    checkProps?: CheckboxProps;
    checkStrictly?: boolean;
    data?: Array<T>;
    disableCheck?: boolean | ((node: TreeNodeModel) => boolean);
    disabled?: boolean;
    draggable?: boolean;
    empty?: string | TNode;
    expandAll?: boolean;
    expanded?: Array<TreeNodeValue>;
    defaultExpanded?: Array<TreeNodeValue>;
    expandLevel?: number;
    expandMutex?: boolean;
    expandOnClickNode?: boolean;
    expandParent?: boolean;
    filter?: (node: TreeNodeModel<T>) => boolean;
    hover?: boolean;
    icon?: boolean | TNode<TreeNodeModel>;
    keys?: TreeKeysType;
    label?: string | boolean | TNode<TreeNodeModel<T>>;
    lazy?: boolean;
    line?: boolean | TNode;
    load?: (node: TreeNodeModel<T>) => Promise<Array<T>>;
    operations?: TNode<TreeNodeModel<T>>;
    transition?: boolean;
    value?: Array<TreeNodeValue>;
    defaultValue?: Array<TreeNodeValue>;
    modelValue?: Array<TreeNodeValue>;
    valueMode?: 'onlyLeaf' | 'parentFirst' | 'all';
    onActive?: (value: Array<TreeNodeValue>, context: {
        node: TreeNodeModel<T>;
    }) => void;
    onChange?: (value: Array<TreeNodeValue>, context: {
        node: TreeNodeModel<T>;
    }) => void;
    onClick?: (context: {
        node: TreeNodeModel<T>;
        e: MouseEvent;
    }) => void;
    onExpand?: (value: Array<TreeNodeValue>, context: {
        node: TreeNodeModel<T>;
        e: MouseEvent;
    }) => void;
    onLoad?: (context: {
        node: TreeNodeModel<T>;
    }) => void;
    onDragStart?: (context: {
        e: DragEvent;
        node: TreeNodeModel<T>;
    }) => void;
    onDragEnd?: (context: {
        e: DragEvent;
        node: TreeNodeModel<T>;
    }) => void;
    onDragOver?: (context: {
        e: DragEvent;
        node: TreeNodeModel<T>;
    }) => void;
    onDragLeave?: (context: {
        e: DragEvent;
        node: TreeNodeModel<T>;
    }) => void;
    onDrop?: (context: {
        e: DragEvent;
        dragNode: TreeNodeModel<T>;
        dropNode: TreeNodeModel<T>;
        dropPosition: number;
    }) => void;
}
export interface TreeInstanceFunctions<T extends TreeOptionData = TreeOptionData> {
    appendTo?: (value: TreeNodeValue, newData: T | Array<T>) => void;
    getIndex?: (value: TreeNodeValue) => number;
    getItem?: (value: TreeNodeValue) => TreeNodeModel<T>;
    getItems?: (value?: TreeNodeValue) => Array<TreeNodeModel<T>>;
    getParent?: (value: TreeNodeValue) => TreeNodeModel<T>;
    getParents?: (value: TreeNodeValue) => TreeNodeModel<T>[];
    getPath?: (value: TreeNodeValue) => TreeNodeModel<T>[];
    insertAfter?: (value: TreeNodeValue, newData: T) => void;
    insertBefore?: (value: TreeNodeValue, newData: T) => void;
    remove?: (value: TreeNodeValue) => void;
    setItem?: (value: TreeNodeValue, options: TreeNodeState) => void;
}
export interface TreeNodeState {
    activable?: boolean;
    actived?: boolean;
    checkable?: boolean;
    checked?: boolean;
    disabled?: boolean;
    draggable?: boolean;
    expanded?: boolean;
    expandMutex?: boolean;
    indeterminate?: boolean;
    label?: string;
    loading?: boolean;
    value?: string | number;
    visible?: boolean;
}
export interface TreeNodeModel<T extends TreeOptionData = TreeOptionData> extends TreeNodeState {
    actived: boolean;
    checked: boolean;
    data: T;
    expanded: boolean;
    indeterminate: boolean;
    loading: boolean;
    appendData: (data: T | Array<T>) => void;
    getChildren: (deep: boolean) => Array<TreeNodeModel> | boolean;
    getIndex: () => number;
    getLevel: () => number;
    getParent: () => TreeNodeModel;
    getParents: () => Array<TreeNodeModel>;
    getPath: () => Array<TreeNodeModel>;
    getRoot: () => TreeNodeModel;
    getSiblings: () => Array<TreeNodeModel>;
    insertAfter: (newData: T) => void;
    insertBefore: (newData: T) => void;
    isFirst: () => boolean;
    isLast: () => boolean;
    isLeaf: () => boolean;
    remove: (value?: TreeNodeValue) => void;
    setData: (data: T) => void;
}
export interface TreeKeysType {
    value?: string;
    label?: string;
    children?: string;
}
export declare type TreeNodeValue = string | number;
