import { OfferParameters } from './OfferParameters';
import { AcceptanceParameters } from './AcceptanceParameters';
import CancellationToken from 'cancellationtoken';
import { FrameHeader } from './FrameHeader';
import { ControlCode } from './ControlCode';
export interface Version {
    major: number;
    minor: number;
}
export interface HandshakeResult {
    isOdd?: boolean;
    protocolVersion: Version;
}
export declare abstract class MultiplexingStreamFormatter {
    isOdd?: boolean;
    abstract writeHandshakeAsync(): Promise<Buffer | null>;
    abstract readHandshakeAsync(writeHandshakeResult: Buffer | null, cancellationToken: CancellationToken): Promise<HandshakeResult>;
    abstract writeFrameAsync(header: FrameHeader, payload?: Buffer): Promise<void>;
    abstract readFrameAsync(cancellationToken: CancellationToken): Promise<{
        header: FrameHeader;
        payload: Buffer;
    } | null>;
    abstract serializeOfferParameters(offer: OfferParameters): Buffer;
    abstract deserializeOfferParameters(payload: Buffer): OfferParameters;
    abstract serializeAcceptanceParameters(acceptance: AcceptanceParameters): Buffer;
    abstract deserializeAcceptanceParameters(payload: Buffer): AcceptanceParameters;
    abstract serializeContentProcessed(bytesProcessed: number): Buffer;
    abstract deserializeContentProcessed(payload: Buffer): number;
    abstract end(): void;
    protected static getIsOddRandomData(): Buffer;
    protected static isOdd(localRandom: Buffer, remoteRandom: Buffer): boolean;
    protected createFrameHeader(code: ControlCode, id: number | undefined): FrameHeader;
}
export declare class MultiplexingStreamV1Formatter extends MultiplexingStreamFormatter {
    private readonly stream;
    /**
     * The magic number to send at the start of communication when using v1 of the protocol.
     */
    private static readonly protocolMagicNumber;
    constructor(stream: NodeJS.ReadWriteStream);
    end(): void;
    writeHandshakeAsync(): Promise<Buffer>;
    readHandshakeAsync(writeHandshakeResult: Buffer, cancellationToken: CancellationToken): Promise<HandshakeResult>;
    writeFrameAsync(header: FrameHeader, payload?: Buffer): Promise<void>;
    readFrameAsync(cancellationToken: CancellationToken): Promise<{
        header: FrameHeader;
        payload: Buffer;
    } | null>;
    serializeOfferParameters(offer: OfferParameters): Buffer;
    deserializeOfferParameters(payload: Buffer): OfferParameters;
    serializeAcceptanceParameters(_: AcceptanceParameters): Buffer;
    deserializeAcceptanceParameters(_: Buffer): AcceptanceParameters;
    serializeContentProcessed(bytesProcessed: number): Buffer;
    deserializeContentProcessed(payload: Buffer): number;
}
export declare class MultiplexingStreamV2Formatter extends MultiplexingStreamFormatter {
    private static readonly protocolVersion;
    private readonly reader;
    protected readonly writer: NodeJS.WritableStream;
    constructor(stream: NodeJS.ReadWriteStream);
    end(): void;
    writeHandshakeAsync(): Promise<Buffer | null>;
    readHandshakeAsync(writeHandshakeResult: Buffer | null, cancellationToken: CancellationToken): Promise<HandshakeResult>;
    writeFrameAsync(header: FrameHeader, payload?: Buffer): Promise<void>;
    readFrameAsync(cancellationToken: CancellationToken): Promise<{
        header: FrameHeader;
        payload: Buffer;
    } | null>;
    serializeOfferParameters(offer: OfferParameters): Buffer;
    deserializeOfferParameters(payload: Buffer): OfferParameters;
    serializeAcceptanceParameters(acceptance: AcceptanceParameters): Buffer;
    deserializeAcceptanceParameters(payload: Buffer): AcceptanceParameters;
    serializeContentProcessed(bytesProcessed: number): Buffer;
    deserializeContentProcessed(payload: Buffer): number;
    serializeException(error: Error | null): Buffer;
    deserializeException(payload: Buffer): Error | null;
    protected readMessagePackAsync(cancellationToken: CancellationToken): Promise<{} | [] | null>;
}
export declare class MultiplexingStreamV3Formatter extends MultiplexingStreamV2Formatter {
    private static readonly protocolV3Version;
    writeHandshakeAsync(): Promise<null>;
    readHandshakeAsync(): Promise<HandshakeResult>;
    writeFrameAsync(header: FrameHeader, payload?: Buffer): Promise<void>;
    readFrameAsync(cancellationToken: CancellationToken): Promise<{
        header: FrameHeader;
        payload: Buffer;
    } | null>;
}