/// <reference types="node" />
/// <reference types="node" />
import * as net from 'net';
import { Observable, Subject } from "rxjs";
import { Bitstream } from "../util";
import { Message, MessageData } from "./syntax";
export interface ChunkStreamState {
    timestamp?: number;
    timestampDelta?: number;
    messageLength?: number;
    messageTypeId?: number;
    messageStreamId?: number;
    messagePayload?: Buffer;
}
export declare type HandshakeState = 'uninitialized' | 'versionSent' | 'ackSent' | 'handshakeDone';
export declare class ChunkStreamWriter {
    private bitstream;
    constructor(bitstream: Bitstream);
    maxChunkSize: number;
    windowSize: number;
    limitType: number;
    messageStreamId: number;
    timestamp: number;
    messageLength: number;
    messageTypeId: number;
    pendingMessages: Map<number, ChunkMessage[]>;
    streamStates: Map<number, ChunkStreamState>;
    private getQueueForStream;
    private getStateForStream;
    private discardMessageFromQueue;
    send(message: ChunkMessage): void;
    setChunkSize(chunkSize: number): void;
    abortMessage(chunkStreamId: number): void;
    setAcknowledgementWindow(acknowledgementWindowSize: number): void;
    setPeerBandwidth(acknowledgementWindowSize: number, limitType: 'hard' | 'soft' | 'dynamic'): void;
    acknowledge(sequenceNumber: number): void;
    private write;
    private writeTimeout;
}
export declare class ChunkStreamSession {
    #private;
    readonly bitstream: Bitstream;
    constructor(bitstream: Bitstream);
    readonly reader: ChunkStreamReader;
    readonly writer: ChunkStreamWriter;
    get messageReceived(): Subject<Message>;
    private receiveMessage;
    send(message: ChunkMessage): void;
    setAcknowledgementWindow(acknowledgementWindowSize: number): void;
    setPeerBandwidth(acknowledgementWindowSize: number, limitType: 'soft' | 'hard' | 'dynamic'): void;
    setChunkSize(chunkSize: number): void;
    static forSocket(socket: net.Socket): ChunkStreamSession;
}
export interface ChunkMessage {
    chunkStreamId: number;
    messageStreamId: number;
    messageTypeId: number;
    timestamp: number;
    /**
     * The message to send.
     */
    data: MessageData;
    buffer?: Buffer;
    bytesSent?: number;
    forceFullHeader?: boolean;
}
export declare class ChunkStreamReader {
    #private;
    private bitstream;
    constructor(bitstream: Bitstream);
    maxChunkSize: number;
    chunkStreams: Map<number, ChunkStreamState>;
    sequenceNumber: number;
    windowSize: number;
    clientVersion: number;
    expectsExtendedTimestamp: boolean;
    get messageReceived(): Observable<Message>;
    get controlMessageReceived(): Observable<Message>;
    get acknowledgements(): Observable<number>;
    private start;
    private handshake;
    private getChunkStream;
    private dispatchMessage;
    private handleControlMessage;
    private parseMessageData;
    private receiveChunk;
}