import { Base, Type, Stream, SeekOrigin, IDisposable } from "igniteui-react-core";
import { IComparer$1 } from "igniteui-react-core";
import { List$1 } from "igniteui-react-core";
import { DirectoryStream_NodeColor } from "./DirectoryStream_NodeColor";
import { StructuredStorageStream_StreamType } from "./StructuredStorageStream_StreamType";
/**
 * @hidden
 */
export declare abstract class DirectoryEntry extends Base {
    static $t: Type;
    private o;
    private s;
    private q;
    private a;
    private c;
    private e;
    private g;
    private i;
    private k;
    constructor(a: string, b: DirectoryStream_DirectoryEntryNode);
    private static u;
    get p(): number;
    set p(a: number);
    get t(): string;
    get l(): DirectoryStream_DirectoryEntryNode;
    get j(): Directory;
    set j(a: Directory);
    get r(): number;
    set r(a: number);
    get b(): number[];
    set b(a: number[]);
    get d(): number[];
    set d(a: number[]);
    get f(): number[];
    set f(a: number[]);
    get h(): number[];
    set h(a: number[]);
    private static m;
    static get n(): IComparer$1<DirectoryEntry>;
}
/**
 * @hidden
 */
export declare class Directory extends DirectoryEntry {
    static $t: Type;
    private x;
    constructor(a: string, b: DirectoryStream_DirectoryEntryNode);
    v(a: string, b: DirectoryStream): SSFile;
    w(a: string, b: string): SSFile;
    get y(): List$1<DirectoryEntry>;
}
/**
 * @hidden
 */
export declare class DirectoryEntry_NameComparer extends Base implements IComparer$1<DirectoryEntry> {
    static $t: Type;
    compare(a: DirectoryEntry, b: DirectoryEntry): number;
}
/**
 * @hidden
 */
export declare abstract class StructuredStorageStream extends Stream {
    static $t: Type;
    private _q;
    private _aj;
    private _y;
    protected _ag: number;
    protected _t: boolean;
    private _ab;
    private _ac;
    private _w;
    private _x;
    private _ad;
    private _ai;
    private _o;
    constructor(a: number, b: StructuredStorageManager, c: number, d: number);
    constructor(a: number, b: StructuredStorageManager, c: number, d: number, e: boolean);
    constructor(a: number, ..._rest: any[]);
    protected get_canRead(): boolean;
    get canRead(): boolean;
    protected get_canSeek(): boolean;
    get canSeek(): boolean;
    protected get_canWrite(): boolean;
    get canWrite(): boolean;
    protected disposeCore(a: boolean): void;
    flush(): void;
    protected get_length(): number;
    get length(): number;
    protected get_position(): number;
    protected set_position(a: number): void;
    get position(): number;
    set position(a: number);
    read(a: number[], b: number, c: number): number;
    seek(a: number, b: SeekOrigin): number;
    setLength(a: number): void;
    write(a: number[], b: number, c: number): void;
    protected _v(a: number): number;
    _aa(a: number, b: number): {
        ret: number;
        p1?: number;
    };
    _readBytes(a: number): number[];
    private _ae;
    _readInt16(): number;
    _readInt32(): number;
    _readUInt16(): number;
    protected _al(): void;
    protected _am(a: number): void;
    _an(a: number): void;
    private _ao;
    private _ap;
    _writeInt16(a: number): void;
    _writeInt32(a: number): void;
    private _ah;
    get _z(): number;
    get _storageManager(): StructuredStorageManager;
    protected get__s(): StructuredStorageStream_StreamType;
    protected get _s(): StructuredStorageStream_StreamType;
}
/**
 * @hidden
 */
export declare class DirectoryEntryStream extends StructuredStorageStream {
    static $t: Type;
    private _as;
    private _at;
    constructor(a: number, b: StructuredStorageManager, c: DirectoryEntry);
    constructor(a: number, b: StructuredStorageManager, c: DirectoryEntry, d: boolean);
    constructor(a: number, ..._rest: any[]);
    protected disposeCore(a: boolean): void;
    protected _am(a: number): void;
    _an(a: number): void;
    write(a: number[], b: number, c: number): void;
}
/**
 * @hidden
 */
export declare class DirectoryStream extends StructuredStorageStream {
    static $t: Type;
    private _as;
    private _av;
    private readonly _az;
    constructor(a: number, b: StructuredStorageManager);
    constructor(a: number, b: StructuredStorageManager, c: number);
    constructor(a: number, ..._rest: any[]);
    protected disposeCore(a: boolean): void;
    _addFile(a: string): SSFile;
    _a0(): void;
    private _a1;
    _readDirectoryEntryHeaders(): void;
    private _a3;
    private _a4;
    private _a5;
    get _aw(): List$1<DirectoryStream_DirectoryEntryNode>;
    get _at(): Directory;
}
/**
 * @hidden
 */
export declare class DirectoryStream_DirectoryEntryNode extends Base {
    static $t: Type;
    constructor();
    a: DirectoryEntry;
    d: number;
    e: number;
    c: number;
    b: DirectoryStream_NodeColor;
}
/**
 * @hidden
 */
export declare class SSFile extends DirectoryEntry {
    static $t: Type;
    constructor(a: string, b: DirectoryStream_DirectoryEntryNode);
}
/**
 * @hidden
 */
export declare class MasterSATStream extends StructuredStorageStream {
    static $t: Type;
    private readonly _a0;
    private _as;
    private _aw;
    private _ax;
    private _av;
    private _au;
    constructor(a: StructuredStorageManager, b: number, c: number, d: number[]);
    protected _v(a: number): number;
    protected disposeCore(a: boolean): void;
    _aa(a: number, b: number): {
        ret: number;
        p1?: number;
    };
    protected get__s(): StructuredStorageStream_StreamType;
    _a1(a: number): void;
    _ay(a: number): number;
    _az(a: number): number;
    get _headerMasterSAT(): number[];
}
/**
 * @hidden
 */
export declare abstract class SATStreamBase extends StructuredStorageStream {
    static $t: Type;
    protected readonly _aw: number;
    private _as;
    private _at;
    constructor(a: StructuredStorageManager, b: number, c: number);
    protected disposeCore(a: boolean): void;
    _au(a: number, b: StructuredStorageStream_StreamType): number;
    _getNextSectorIdInSAT(a: number, b: number): {
        ret: number;
        p1?: number;
    };
    protected _ax(a: number, b: number): void;
    _ay(a: StructuredStorageStream): void;
    protected _az(a: List$1<SATStreamBase_SATEntry>): void;
}
/**
 * @hidden
 */
export declare class SATStream extends SATStreamBase {
    static $t: Type;
    private _a0;
    constructor(a: number, b: StructuredStorageManager, c: MasterSATStream);
    constructor(a: number, b: StructuredStorageManager, c: number, d: number, e: MasterSATStream);
    constructor(a: number, ..._rest: any[]);
    protected _v(a: number): number;
    protected disposeCore(a: boolean): void;
    _aa(a: number, b: number): {
        ret: number;
        p1?: number;
    };
    protected get__s(): StructuredStorageStream_StreamType;
    get _masterSATStream(): MasterSATStream;
}
/**
 * @hidden
 */
export declare class SATStreamBase_SATEntry extends Base {
    static $t: Type;
    c: number;
    b: number;
    constructor(a: number, b: number);
    static get a(): SATStreamBase_SATEntry;
}
/**
 * @hidden
 */
export declare class ShortSATStream extends SATStreamBase {
    static $t: Type;
    constructor(a: StructuredStorageManager, b: number, c: number);
}
/**
 * @hidden
 */
export declare class StructuredStorageManager extends Base implements IDisposable {
    static $t: Type;
    private _k;
    private _ag;
    private _ah;
    private _w;
    private _x;
    private _u;
    private _ae;
    private _b;
    private _d;
    private _e;
    private _c;
    private _h;
    private _f;
    constructor(a: Stream, b: boolean);
    _ab(a: string): Stream;
    _ac(a: string): Stream;
    static _j(a: Stream): boolean;
    protected _dispose1(a: boolean): void;
    _l(a: number, b: boolean, c: StructuredStorageStream_StreamType): number;
    _y(a: number, b: number, c: boolean): number;
    _ad(a: boolean): Stream;
    _o(a: number, b: number, c: boolean): {
        ret: number;
        p1?: number;
    };
    _p(a: boolean): number;
    _i(a: number): boolean;
    _z(a: number, b: boolean): number;
    _aa(a: number, b: number, c: boolean): number;
    _am(a: UserFileStream): void;
    get _g(): boolean;
    set _g(a: boolean);
    get _a(): Directory;
    dispose(): void;
}
/**
 * @hidden
 */
export declare class UserFileStream extends DirectoryEntryStream {
    static $t: Type;
    private _au;
    constructor(a: StructuredStorageManager, b: SSFile);
    setLength(a: number): void;
    get _isShortStream(): boolean;
}