import { Readable, ReadableOptions, Writable, WritableOptions } from 'stream';
export declare class ReadAfterDestroyedError extends Error {
    constructor();
}
export declare class ReadAfterReleasedError extends Error {
    constructor();
}
export interface ReadStreamOptions {
    highWaterMark?: ReadableOptions['highWaterMark'];
    encoding?: ReadableOptions['encoding'];
}
export declare class ReadStream extends Readable {
    private _pos;
    private readonly _writeStream;
    private _retryListenersAttached;
    constructor(writeStream: WriteStream, options?: ReadStreamOptions);
    private _retry;
    private _attachRetryListeners;
    private _detachRetryListeners;
    _read(n: number): void;
    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
}
export interface WriteStreamOptions {
    highWaterMark?: WritableOptions['highWaterMark'];
    defaultEncoding?: WritableOptions['defaultEncoding'];
    tmpdir?: () => string;
}
export declare class WriteStream extends Writable {
    private _fd;
    private _path;
    private _pos;
    private readonly _readStreams;
    private _released;
    private _tmpdir;
    constructor(options?: WriteStreamOptions);
    private _initFile;
    getFd(): number | null;
    getWritePosition(): number;
    isWritableFinished(): boolean;
    private _cleanup;
    private _cleanupSync;
    _final(callback: (error?: Error | null) => void): void;
    _write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void;
    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
    createReadStream(options?: ReadStreamOptions): ReadStream;
    release(): void;
}
declare const _default: {
    WriteStream: typeof WriteStream;
    ReadStream: typeof ReadStream;
    ReadAfterDestroyedError: typeof ReadAfterDestroyedError;
    ReadAfterReleasedError: typeof ReadAfterReleasedError;
};
export default _default;