/// <reference types="node" />
import { SCTP_STATE } from "./const";
import { Chunk, ForwardTsnChunk, DataChunk } from "./chunk";
import { Transport } from "./transport";
import { Event } from "rx.mini";
import { Unpacked } from "./helper";
import { StreamResetOutgoingParam, StreamParam } from "./param";
declare const SCTPConnectionStates: readonly ["new", "closed", "connected", "connecting"];
declare type SCTPConnectionState = Unpacked<typeof SCTPConnectionStates>;
export declare class SCTP {
    transport: Transport;
    port: number;
    stateChanged: {
        [key in SCTPConnectionState]: Event;
    };
    associationState: SCTP_STATE;
    started: boolean;
    state: SCTPConnectionState;
    private hmacKey;
    isServer: boolean;
    private localPartialReliability;
    private localPort;
    private localVerificationTag;
    remoteExtensions: number[];
    remotePartialReliability: boolean;
    private remotePort?;
    private remoteVerificationTag;
    private advertisedRwnd;
    private inboundStreams;
    _inboundStreamsCount: number;
    _inboundStreamsMax: number;
    private lastReceivedTsn?;
    private sackDuplicates;
    private sackMisOrdered;
    private sackNeeded;
    private cwnd;
    private fastRecoveryExit?;
    private fastRecoveryTransmit;
    private forwardTsnChunk?;
    private flightSize;
    outboundQueue: DataChunk[];
    private outboundStreamSeq;
    _outboundStreamsCount: number;
    private localTsn;
    private lastSackedTsn;
    private advancedPeerAckTsn;
    private partialBytesAcked;
    private sentQueue;
    reconfigRequestSeq: number;
    reconfigResponseSeq: number;
    reconfigRequest?: StreamResetOutgoingParam;
    reconfigQueue: number[];
    private srtt?;
    private rttvar?;
    private rto;
    private t1Handle?;
    private t1Chunk?;
    private t1Failures;
    private t2Handle?;
    private t2Chunk?;
    private t2Failures;
    private t3Handle?;
    private ssthresh?;
    constructor(transport: Transport, port?: number);
    get maxChannels(): number;
    static client(transport: Transport, port?: number): SCTP;
    static server(transport: Transport, port?: number): SCTP;
    private handleData;
    private sendSack;
    private receiveChunk;
    private getExtensions;
    onDeleteStreams: (streamIds: number[]) => void;
    private receiveReconfigParam;
    private receiveDataChunk;
    private receiveSackChunk;
    receiveForwardTsnChunk(chunk: ForwardTsnChunk): void;
    private updateRto;
    onRecieve?: (streamId: number, ppId: number, data: Buffer) => void;
    private receive;
    private getInboundStream;
    private markReceived;
    send(streamId: number, ppId: number, userData: Buffer, expiry?: number | undefined, maxRetransmits?: number | undefined, ordered?: boolean): void;
    private transmit;
    transmitReconfig(): void;
    sendReconfigParam(param: StreamParam): void;
    sendResetRequest(streamId: number): void;
    private flightSizeIncrease;
    private flightSizeDecrease;
    private t1Cancel;
    private t1Expired;
    private t1Start;
    private t2Cancel;
    private t2Expired;
    private t2Start;
    private t3Expired;
    private t3Restart;
    private t3Start;
    private t3Cancel;
    private updateAdvancedPeerAckPoint;
    private maybeAbandon;
    static getCapabilities(): RTCSctpCapabilities;
    start(remotePort: number): void;
    private init;
    private setExtensions;
    sendChunk(chunk: Chunk): void;
    setState(state: SCTP_STATE): void;
    setConnectionState(state: SCTPConnectionState): void;
    stop(): void;
    abort(): void;
    private removeAllListeners;
}
export declare class InboundStream {
    reassembly: DataChunk[];
    sequenceNumber: number;
    addChunk(chunk: DataChunk): void;
    popMessages(): Generator<[number, number, Buffer]>;
    pruneChunks(tsn: number): number;
}
export declare class RTCSctpCapabilities {
    maxMessageSize: number;
    constructor(maxMessageSize: number);
}
export {};