import { Type, Base, ICollection$1, IEnumerable$1, IEnumerator$1, IEnumerator } from "igniteui-angular-core";
import { List$1 } from "igniteui-angular-core";
import { LoadOnDemandTree_FindState } from "./LoadOnDemandTree_FindState";
import { LoadOnDemandTree_ChangeHistoryItem$1 } from "./LoadOnDemandTree_ChangeHistoryItem$1";
import { ILoadOnDemandTreeOwner$1 } from "./ILoadOnDemandTreeOwner$1";
/**
 * @hidden
 */
export interface IBinaryTreeNodeOwner$1<T> {
    recalculateHeight(): boolean;
    verifyBalanceOfChild(a: LoadOnDemandTree_BinaryTreeNode$1<T>): boolean;
}
/**
 * @hidden
 */
export declare let IBinaryTreeNodeOwner$1_$type: Type;
/**
 * @hidden
 */
export declare class LoadOnDemandTree$1<T> extends Base implements ICollection$1<T>, IBinaryTreeNodeOwner$1<T> {
    static $t: Type;
    protected $t: Type;
    _a: ILoadOnDemandTreeOwner$1<T>;
    private _aj;
    protected _h: LoadOnDemandTree_BinaryTreeNode$1<T>;
    private _i;
    private _ae;
    private _n;
    private _q;
    private _r;
    private _s;
    private _ab;
    private _aa;
    constructor($t: Type, a: ILoadOnDemandTreeOwner$1<T>, b: number);
    recalculateHeight(): boolean;
    verifyBalanceOfChild(a: LoadOnDemandTree_BinaryTreeNode$1<T>): boolean;
    add(a: T): void;
    clear(): void;
    contains(a: T): boolean;
    copyTo(a: T[], b: number): void;
    readonly isReadOnly: boolean;
    remove(a: T): boolean;
    getEnumerator(): IEnumerator$1<T>;
    private __x;
    _x(a: number, b: number, c: boolean): IEnumerable$1<T>;
    getEnumeratorObject(): IEnumerator;
    _af(a: number, b: number): number;
    _ah(a: number): number;
    _ai(a: number): number;
    private _j;
    _k(a: LoadOnDemandTree_ChangeHistoryItem$1<T>, b: number, c: number): LoadOnDemandTree_ChangeAdjustmentPoint$1<T>;
    protected _l(a: number, b: number): LoadOnDemandTree_ChangeHistoryItem$1<T>;
    protected _m(a: number, b: number): LoadOnDemandTree_ChangeHistoryItem$1<T>;
    _f(a: number, b: IBinaryTreeNodeOwner$1<T>): LoadOnDemandTree_BinaryTreeNode$1<T>;
    private __w;
    private _w;
    protected _y(): IEnumerable$1<LoadOnDemandTree_BinaryTreeNode$1<T>>;
    private __z;
    protected _z(a: number, b: number, c: boolean): IEnumerable$1<LoadOnDemandTree_BinaryTreeNode$1<T>>;
    _b(a: number, b: boolean, c: LoadOnDemandTree_FindState): {
        ret: T;
        p2: LoadOnDemandTree_FindState;
    };
    _ao(a: number, b: number): void;
    private static _aq;
    _ar(a: number, b: number): void;
    _e(a: T, b: number): T;
    _p(a: number, b: T): {
        ret: boolean;
        p1: T;
    };
    private _am;
    _an(): void;
    _o(a: number, b: number): boolean;
    private _ap;
    private _d;
    private _g;
    private _as;
    protected readonly _ac: List$1<LoadOnDemandTree_ChangeAdjustmentPoint$1<T>>;
    readonly _u: number;
    readonly count: number;
    _item(a: number): T;
    _al: number;
    private readonly _ad;
}
/**
 * @hidden
 */
export declare class LoadOnDemandTree_ChangeAdjustmentPoint$1<T> extends Base {
    static $t: Type;
    protected $t: Type;
    protected readonly a: LoadOnDemandTree$1<T>;
    private i;
    private h;
    private j;
    readonly c: LoadOnDemandTree_ChangeHistoryItem$1<T>;
    constructor($t: Type, a: LoadOnDemandTree$1<T>, b: LoadOnDemandTree_ChangeHistoryItem$1<T>, c: number, d: number);
    readonly n: number;
    readonly l: number;
    readonly m: number;
    k: number;
    readonly p: number;
    readonly o: number;
    readonly d: boolean;
    readonly e: boolean;
    item(a: number, b?: T): T;
    q(a: LoadOnDemandTree_ChangeAdjustmentPoint$1<T>, b: List$1<LoadOnDemandTree_ChangeAdjustmentPoint$1<T>>, c: boolean): {
        p2?: boolean;
    };
    private r;
    private s;
    protected t(): void;
    f(a: number, b: number): boolean;
    private g;
    u(a: number): void;
}
/**
 * @hidden
 */
export declare class LoadOnDemandTree_BinaryTreeNode$1<T> extends Base implements IBinaryTreeNodeOwner$1<T> {
    static $t: Type;
    protected $t: Type;
    private n;
    private k;
    private c;
    private f;
    private h;
    protected a: T[];
    constructor($t: Type, a: number, b: IBinaryTreeNodeOwner$1<T>, c: LoadOnDemandTree$1<T>);
    verifyBalanceOfChild(a: LoadOnDemandTree_BinaryTreeNode$1<T>): boolean;
    static j<T>($t: Type, a: LoadOnDemandTree_BinaryTreeNode$1<T>): {
        ret: boolean;
        p0?: LoadOnDemandTree_BinaryTreeNode$1<T>;
    };
    e(a: number, b: number, c: boolean, d: boolean, e: LoadOnDemandTree$1<T>, f: LoadOnDemandTree_FindState): {
        ret: LoadOnDemandTree_BinaryTreeNode$1<T>;
        p5: LoadOnDemandTree_FindState;
    };
    private static m;
    recalculateHeight(): boolean;
    readonly l: number;
    g: LoadOnDemandTree_BinaryTreeNode$1<T>;
    readonly d: IBinaryTreeNodeOwner$1<T>;
    i: LoadOnDemandTree_BinaryTreeNode$1<T>;
    readonly b: T[];
}
