export declare type Dir = 'left' | 'right';
export interface ITreeNode<T> {
    data: T;
    parent?: ITreeNode<T>;
    left?: ITreeNode<T>;
    right?: ITreeNode<T>;
    level?: number;
    balance?: number;
    red?: boolean;
    [dir: string]: ITreeNode<T> | T | number | boolean;
}
export default class Tree<T> {
    protected __root: ITreeNode<T>;
    constructor(cmp?: (a: T, b: T) => number);
    compare: (a: T, b: T) => number;
    get_root(): ITreeNode<T>;
    set_root(root: ITreeNode<T>): void;
    insert(data: T): void;
    remove(data: T): void;
    clear(): void;
    isEmpty(): boolean;
    print(): void;
    /**
     * Prints a node
     * @param node node to print
     * @param level the current level the node is at, Used for formatting
     */
    __printNode(node: ITreeNode<T>, level: number): void;
    forEach(cb: (data: T, tree: Tree<T>) => void, order: string): void;
    traverse(node: ITreeNode<T>, order?: string, callback?: (data: T) => void): void;
    traverseWithCondition(node: ITreeNode<T>, order?: string, callback?: (data: T) => boolean): boolean;
    map(cb: (data: T, tree: Tree<T>) => T, order: string): Tree<T>;
    filter(cb: (data: T, tree: Tree<T>) => boolean, order: string): Tree<T>;
    some(cb: (data: T, tree: Tree<T>) => boolean, order: string): boolean;
    every(cb: (data: T, tree: Tree<T>) => boolean, order: string): boolean;
    toArray(order?: string): T[];
    reduce(fun: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, accumulator?: T, order?: string): T;
    reduce<U>(fun: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, accumulator?: U, order?: string): U;
    reduceRight(fun: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, accumulator?: T, order?: string): T;
    reduceRight<U>(fun: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => T, accumulator?: U, order?: string): U;
    contains(value: T): boolean;
    find(value: T): T;
    findLessThan(value: T, exclusive?: boolean): T[];
    findGreaterThan(value: T, exclusive?: boolean): T[];
}