@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/sctp/const.d.ts

@@ -0,0 +1,17 @@
+export declare enum WEBRTC_PPID {
+    DCEP = 50,
+    STRING = 51,
+    BINARY = 53,
+    STRING_EMPTY = 56,
+    BINARY_EMPTY = 57
+}
+export declare enum SCTP_STATE {
+    CLOSED = 1,
+    COOKIE_WAIT = 2,
+    COOKIE_ECHOED = 3,
+    ESTABLISHED = 4,
+    SHUTDOWN_PENDING = 5,
+    SHUTDOWN_SENT = 6,
+    SHUTDOWN_RECEIVED = 7,
+    SHUTDOWN_ACK_SENT = 8
+}

package/dist/cjs/lib/sctp/const.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCTP_STATE = exports.WEBRTC_PPID = void 0;
+var WEBRTC_PPID;
+(function (WEBRTC_PPID) {
+    WEBRTC_PPID[WEBRTC_PPID["DCEP"] = 50] = "DCEP";
+    WEBRTC_PPID[WEBRTC_PPID["STRING"] = 51] = "STRING";
+    WEBRTC_PPID[WEBRTC_PPID["BINARY"] = 53] = "BINARY";
+    WEBRTC_PPID[WEBRTC_PPID["STRING_EMPTY"] = 56] = "STRING_EMPTY";
+    WEBRTC_PPID[WEBRTC_PPID["BINARY_EMPTY"] = 57] = "BINARY_EMPTY";
+})(WEBRTC_PPID || (exports.WEBRTC_PPID = WEBRTC_PPID = {}));
+var SCTP_STATE;
+(function (SCTP_STATE) {
+    SCTP_STATE[SCTP_STATE["CLOSED"] = 1] = "CLOSED";
+    SCTP_STATE[SCTP_STATE["COOKIE_WAIT"] = 2] = "COOKIE_WAIT";
+    SCTP_STATE[SCTP_STATE["COOKIE_ECHOED"] = 3] = "COOKIE_ECHOED";
+    SCTP_STATE[SCTP_STATE["ESTABLISHED"] = 4] = "ESTABLISHED";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_PENDING"] = 5] = "SHUTDOWN_PENDING";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_SENT"] = 6] = "SHUTDOWN_SENT";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_RECEIVED"] = 7] = "SHUTDOWN_RECEIVED";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_ACK_SENT"] = 8] = "SHUTDOWN_ACK_SENT";
+})(SCTP_STATE || (exports.SCTP_STATE = SCTP_STATE = {}));

package/dist/cjs/lib/sctp/helper.d.ts

@@ -0,0 +1,5 @@
+export declare function enumerate<T>(arr: T[]): [number, T][];
+export type Unpacked<T> = T extends {
+    [K in keyof T]: infer U;
+} ? U : never;
+export declare function createEventsFromList<T>(list: readonly T[]): any;

package/dist/cjs/lib/sctp/helper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumerate = enumerate;
+exports.createEventsFromList = createEventsFromList;
+const common_js_1 = require("./imports/common.js");
+function enumerate(arr) {
+    return arr.map((v, i) => [i, v]);
+}
+function createEventsFromList(list) {
+    return list.reduce((acc, cur) => {
+        acc[cur] = new common_js_1.Event();
+        return acc;
+    }, {});
+}

package/dist/cjs/lib/sctp/imports/common.d.ts

@@ -0,0 +1 @@
+export * from '../../common/index.js';

package/dist/cjs/lib/sctp/imports/common.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../common/index.js"), exports);

package/dist/cjs/lib/sctp/index.d.ts

@@ -0,0 +1,6 @@
+export { SCTP_STATE, WEBRTC_PPID } from './const.js';
+export { SCTP, DEFAULT_SCTP_MTU, maxPayloadSizeForMtu, validateSctpMtu } from './sctp.js';
+export type { SCTPOptions } from './sctp.js';
+export { SCTP_COMMON_HEADER_SIZE, SCTP_CHUNK_HEADER_SIZE, SCTP_DATA_FIXED_HEADER_SIZE, SCTP_DATA_CHUNK_HEADER_SIZE, SCTP_PADDING_MULTIPLE } from './chunk.js';
+export { createUdpTransport, UdpTransport } from './transport.js';
+export type { Transport } from './transport.js';

package/dist/cjs/lib/sctp/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UdpTransport = exports.createUdpTransport = exports.SCTP_PADDING_MULTIPLE = exports.SCTP_DATA_CHUNK_HEADER_SIZE = exports.SCTP_DATA_FIXED_HEADER_SIZE = exports.SCTP_CHUNK_HEADER_SIZE = exports.SCTP_COMMON_HEADER_SIZE = exports.validateSctpMtu = exports.maxPayloadSizeForMtu = exports.DEFAULT_SCTP_MTU = exports.SCTP = exports.WEBRTC_PPID = exports.SCTP_STATE = void 0;
+var const_js_1 = require("./const.js");
+Object.defineProperty(exports, "SCTP_STATE", { enumerable: true, get: function () { return const_js_1.SCTP_STATE; } });
+Object.defineProperty(exports, "WEBRTC_PPID", { enumerable: true, get: function () { return const_js_1.WEBRTC_PPID; } });
+var sctp_js_1 = require("./sctp.js");
+Object.defineProperty(exports, "SCTP", { enumerable: true, get: function () { return sctp_js_1.SCTP; } });
+Object.defineProperty(exports, "DEFAULT_SCTP_MTU", { enumerable: true, get: function () { return sctp_js_1.DEFAULT_SCTP_MTU; } });
+Object.defineProperty(exports, "maxPayloadSizeForMtu", { enumerable: true, get: function () { return sctp_js_1.maxPayloadSizeForMtu; } });
+Object.defineProperty(exports, "validateSctpMtu", { enumerable: true, get: function () { return sctp_js_1.validateSctpMtu; } });
+var chunk_js_1 = require("./chunk.js");
+Object.defineProperty(exports, "SCTP_COMMON_HEADER_SIZE", { enumerable: true, get: function () { return chunk_js_1.SCTP_COMMON_HEADER_SIZE; } });
+Object.defineProperty(exports, "SCTP_CHUNK_HEADER_SIZE", { enumerable: true, get: function () { return chunk_js_1.SCTP_CHUNK_HEADER_SIZE; } });
+Object.defineProperty(exports, "SCTP_DATA_FIXED_HEADER_SIZE", { enumerable: true, get: function () { return chunk_js_1.SCTP_DATA_FIXED_HEADER_SIZE; } });
+Object.defineProperty(exports, "SCTP_DATA_CHUNK_HEADER_SIZE", { enumerable: true, get: function () { return chunk_js_1.SCTP_DATA_CHUNK_HEADER_SIZE; } });
+Object.defineProperty(exports, "SCTP_PADDING_MULTIPLE", { enumerable: true, get: function () { return chunk_js_1.SCTP_PADDING_MULTIPLE; } });
+var transport_js_1 = require("./transport.js");
+Object.defineProperty(exports, "createUdpTransport", { enumerable: true, get: function () { return transport_js_1.createUdpTransport; } });
+Object.defineProperty(exports, "UdpTransport", { enumerable: true, get: function () { return transport_js_1.UdpTransport; } });

package/dist/cjs/lib/sctp/param.d.ts

@@ -0,0 +1,40 @@
+export declare class OutgoingSSNResetRequestParam {
+    requestSequence: number;
+    responseSequence: number;
+    lastTsn: number;
+    streams: number[];
+    static type: number;
+    constructor(requestSequence: number, responseSequence: number, lastTsn: number, streams: number[]);
+    get type(): number;
+    get bytes(): Buffer<ArrayBuffer>;
+    static parse(data: Buffer): OutgoingSSNResetRequestParam;
+}
+export declare class StreamAddOutgoingParam {
+    requestSequence: number;
+    newStreams: number;
+    static type: number;
+    constructor(requestSequence: number, newStreams: number);
+    get type(): number;
+    get bytes(): Buffer<ArrayBuffer>;
+    static parse(data: Buffer): StreamAddOutgoingParam;
+}
+export declare const reconfigResult: {
+    readonly ReconfigResultSuccessPerformed: 1;
+    readonly BadSequenceNumber: 5;
+};
+type ReconfigResult = (typeof reconfigResult)[keyof typeof reconfigResult];
+export declare class ReconfigResponseParam {
+    responseSequence: number;
+    result: ReconfigResult;
+    static type: number;
+    constructor(responseSequence: number, result: ReconfigResult);
+    get type(): number;
+    get bytes(): Buffer<ArrayBuffer>;
+    static parse(data: Buffer): ReconfigResponseParam;
+}
+export type StreamParam = OutgoingSSNResetRequestParam | StreamAddOutgoingParam | ReconfigResponseParam;
+export type StreamParamType = typeof OutgoingSSNResetRequestParam | typeof StreamAddOutgoingParam | typeof ReconfigResponseParam;
+export declare const RECONFIG_PARAM_BY_TYPES: {
+    [type: number]: StreamParamType;
+};
+export {};

package/dist/cjs/lib/sctp/param.js

@@ -0,0 +1,132 @@
+"use strict";
+// This parameter is used by the sender to request the reset of some or
+// all outgoing streams.
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |     Parameter Type = 13       | Parameter Length = 16 + 2 * N |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |           Re-configuration Request Sequence Number            |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |           Re-configuration Response Sequence Number           |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                Sender's Last Assigned TSN                     |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |  Stream Number 1 (optional)   |    Stream Number 2 (optional) |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// /                            ......                             /
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |  Stream Number N-1 (optional) |    Stream Number N (optional) |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECONFIG_PARAM_BY_TYPES = exports.ReconfigResponseParam = exports.reconfigResult = exports.StreamAddOutgoingParam = exports.OutgoingSSNResetRequestParam = void 0;
+class OutgoingSSNResetRequestParam {
+    static { this.type = 13; } // Outgoing SSN Reset Request Parameter
+    constructor(requestSequence, responseSequence, lastTsn, streams) {
+        this.requestSequence = requestSequence;
+        this.responseSequence = responseSequence;
+        this.lastTsn = lastTsn;
+        this.streams = streams;
+    }
+    get type() {
+        return OutgoingSSNResetRequestParam.type;
+    }
+    get bytes() {
+        // !LLL — requestSequence / responseSequence / lastTsn (big-endian uint32)
+        const data = Buffer.allocUnsafe(12);
+        data.writeUInt32BE(this.requestSequence, 0);
+        data.writeUInt32BE(this.responseSequence, 4);
+        data.writeUInt32BE(this.lastTsn, 8);
+        return Buffer.concat([
+            data,
+            ...this.streams.map((stream) => {
+                const buf = Buffer.allocUnsafe(2);
+                buf.writeUInt16BE(stream, 0);
+                return buf;
+            })
+        ]);
+    }
+    static parse(data) {
+        const requestSequence = data.readUInt32BE(0);
+        const responseSequence = data.readUInt32BE(4);
+        const lastTsn = data.readUInt32BE(8);
+        const stream = [];
+        for (let pos = 12; pos < data.length; pos += 2) {
+            stream.push(data.readUInt16BE(pos));
+        }
+        return new OutgoingSSNResetRequestParam(requestSequence, responseSequence, lastTsn, stream);
+    }
+}
+exports.OutgoingSSNResetRequestParam = OutgoingSSNResetRequestParam;
+class StreamAddOutgoingParam {
+    static { this.type = 17; } // Add Outgoing Streams Request Parameter
+    constructor(requestSequence, newStreams) {
+        this.requestSequence = requestSequence;
+        this.newStreams = newStreams;
+    }
+    get type() {
+        return StreamAddOutgoingParam.type;
+    }
+    get bytes() {
+        // !LHH — requestSequence / newStreams / reserved
+        const buf = Buffer.allocUnsafe(8);
+        buf.writeUInt32BE(this.requestSequence, 0);
+        buf.writeUInt16BE(this.newStreams, 4);
+        buf.writeUInt16BE(0, 6);
+        return buf;
+    }
+    static parse(data) {
+        const requestSequence = data.readUInt32BE(0);
+        const newStreams = data.readUInt16BE(4);
+        return new StreamAddOutgoingParam(requestSequence, newStreams);
+    }
+}
+exports.StreamAddOutgoingParam = StreamAddOutgoingParam;
+// This parameter is used by the receiver of a Re-configuration Request
+// Parameter to respond to the request.
+//
+// 0                   1                   2                   3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |     Parameter Type = 16       |      Parameter Length         |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |         Re-configuration Response Sequence Number             |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                            Result                             |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                   Sender's Next TSN (optional)                |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                  Receiver's Next TSN (optional)               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+exports.reconfigResult = {
+    ReconfigResultSuccessPerformed: 1,
+    BadSequenceNumber: 5
+};
+class ReconfigResponseParam {
+    static { this.type = 16; } // Re-configuration Response Parameter
+    constructor(responseSequence, result) {
+        this.responseSequence = responseSequence;
+        this.result = result;
+    }
+    get type() {
+        return ReconfigResponseParam.type;
+    }
+    get bytes() {
+        // !LL — responseSequence / result
+        const buf = Buffer.allocUnsafe(8);
+        buf.writeUInt32BE(this.responseSequence, 0);
+        buf.writeUInt32BE(this.result, 4);
+        return buf;
+    }
+    static parse(data) {
+        const requestSequence = data.readUInt32BE(0);
+        const result = data.readUInt32BE(4);
+        return new ReconfigResponseParam(requestSequence, result);
+    }
+}
+exports.ReconfigResponseParam = ReconfigResponseParam;
+exports.RECONFIG_PARAM_BY_TYPES = {
+    13: OutgoingSSNResetRequestParam, // Outgoing SSN Reset Request Parameter
+    16: ReconfigResponseParam, // Re-configuration Response Parameter
+    17: StreamAddOutgoingParam // Add Outgoing Streams Request Parameter
+};

package/dist/cjs/lib/sctp/sctp.d.ts

@@ -0,0 +1,210 @@
+import { type Chunk, DataChunk, ForwardTsnChunk } from './chunk.js';
+import { SCTP_STATE } from './const.js';
+import { type Unpacked } from './helper.js';
+import { Deque, Event } from './imports/common.js';
+import { OutgoingSSNResetRequestParam, type StreamParam } from './param.js';
+import type { Transport } from './transport.js';
+export declare const DEFAULT_SCTP_MTU = 1191;
+export interface SCTPOptions {
+    /** SCTP packet MTU used for outbound DATA chunk fragmentation. */
+    mtu?: number;
+}
+export declare function maxPayloadSizeForMtu(mtu: number, dataChunkHeaderSize?: number): number;
+export declare function validateSctpMtu(mtu: number): void;
+declare const SCTPConnectionStates: readonly ["new", "closed", "connected", "connecting"];
+type SCTPConnectionState = Unpacked<typeof SCTPConnectionStates>;
+export declare class SCTP {
+    transport: Transport;
+    port: number;
+    flush: Event<[void]>;
+    readonly stateChanged: {
+        [key in SCTPConnectionState]: Event<[]>;
+    };
+    readonly onReconfigStreams: Event<[number[]]>;
+    /**streamId: number, ppId: number, data: Buffer */
+    readonly onReceive: Event<[number, number, Buffer<ArrayBufferLike>]>;
+    onSackReceived: () => Promise<void>;
+    associationState: SCTP_STATE;
+    started: boolean;
+    state: SCTPConnectionState;
+    isServer: boolean;
+    private isStopping;
+    private isClosed;
+    private hmacKey;
+    private localPartialReliability;
+    private localPort;
+    private localVerificationTag;
+    remoteExtensions: number[];
+    remotePartialReliability: boolean;
+    private remotePort?;
+    private remoteVerificationTag;
+    private advertisedRwnd;
+    private lastAdvertisedRwnd;
+    private peerAdvertisedRwnd;
+    private get peerRwnd();
+    private inboundStreams;
+    _inboundStreamsCount: number;
+    _inboundStreamsMax: number;
+    private lastReceivedTsn?;
+    private highestReceivedTsn?;
+    private pendingChunks;
+    private sackDuplicates;
+    private sackMisOrdered;
+    private sackNeeded;
+    private sackPacketCount;
+    private sackHasNewDataInPacket;
+    private sackImmediate;
+    private sackTimeout;
+    private cwnd;
+    readonly mtu: number;
+    private readonly maxPayloadSize;
+    private fastRecoveryExit?;
+    private fastRecoveryTransmit;
+    private forwardTsnChunk?;
+    private flightSize;
+    outboundQueue: Deque<DataChunk>;
+    private outboundStreamSeq;
+    _outboundStreamsCount: number;
+    /**local transmission sequence number */
+    private localTsn;
+    private lastSackedTsn;
+    private advancedPeerAckTsn;
+    private partialBytesAcked;
+    private sentQueue;
+    /**some chunks of the sent queue are marked for retransmission: the queue is only walked then */
+    private retransmitPending;
+    /**called for each DATA chunk on its first transmission: the bytes leave the send buffer (bufferedAmount) */
+    onSent?: (streamId: number, ppId: number, bytes: number) => void;
+    private transmitting;
+    private transmitRequested;
+    private transmitScheduled;
+    /**初期TSNと同じ値に初期化される単調に増加する数です. これは、新しいre-configuration requestパラメーターを送信するたびに1ずつ増加します */
+    reconfigRequestSeq: number;
+    /**このフィールドは、incoming要求のre-configuration requestシーケンス番号を保持します. 他の場合では、次に予想されるre-configuration requestシーケンス番号から1を引いた値が保持されます */
+    reconfigResponseSeq: number;
+    reconfigRequest?: OutgoingSSNResetRequestParam;
+    reconfigQueue: number[];
+    private srtt?;
+    private rttvar?;
+    private rto;
+    /**t1 is wait for initAck or cookieAck */
+    private timer1Handle?;
+    private timer1Chunk?;
+    private timer1Failures;
+    /**t2 is wait for shutdown */
+    private timer2Handle?;
+    private timer2Chunk?;
+    private timer2Failures;
+    /**t3 is wait for data sack */
+    private timer3Handle?;
+    /**Re-configuration Timer */
+    private timerReconfigHandle?;
+    private timerReconfigFailures;
+    private timerHeartbeatHandle?;
+    private heartbeatInterval;
+    private ssthresh?;
+    constructor(transport: Transport, port?: number, options?: SCTPOptions);
+    private get isStopped();
+    get maxChannels(): number | undefined;
+    static client(transport: Transport, port?: number, options?: SCTPOptions): SCTP;
+    static server(transport: Transport, port?: number, options?: SCTPOptions): SCTP;
+    private handleData;
+    private scheduleSack;
+    private sendSack;
+    /**The SACK of what was received so far; the state of the pending SACK is reset, its timer cancelled */
+    private takeSack;
+    private receiveChunk;
+    private getExtensions;
+    private receiveReconfigParam;
+    private receiveDataChunk;
+    private receiveSackChunk;
+    receiveForwardTsnChunk(chunk: ForwardTsnChunk): void;
+    private updateRto;
+    private receive;
+    private getInboundStream;
+    private markReceived;
+    /**
+     * Keep bytes received out of the receive window while the application holds them (it passes them on later): the
+     * sender waits once the window is closed
+     * @param bytes
+     */
+    holdReceived(bytes: number): void;
+    /**
+     * Give back to the receive window bytes held; the sender is told at once when the window it knows is less than half
+     * of the window now
+     * @param bytes
+     */
+    releaseReceived(bytes: number): void;
+    send: (streamId: number, ppId: number, userData: Buffer, { expiry, maxRetransmits, ordered }?: {
+        expiry?: number | undefined;
+        maxRetransmits?: number | undefined;
+        ordered?: boolean;
+    }) => Promise<void>;
+    /**
+     * Transmit at the end of the current task, once: a burst of small messages fills packets, rather than going out
+     * one by one while the congestion window has room
+     */
+    private transmitSoon;
+    private transmit;
+    /**
+   * Sends what the windows allow: FORWARD TSN, then the retransmissions, then the queued DATA, bundled in packets of the
+   * MTU; a pending SACK goes in front of the first DATA. The packets are handed to the transport without waiting: the
+   * DTLS records are numbered and encrypted when sent, so their order holds
+   */
+    private transmitOnce;
+    /**One packet of chunks, handed to the transport without waiting for it */
+    private sendChunks;
+    transmitReconfigRequest(): Promise<void>;
+    sendReconfigParam(param: StreamParam): Promise<void>;
+    private sendResetRequest;
+    private flightSizeIncrease;
+    private flightSizeDecrease;
+    /**t1 is wait for initAck or cookieAck */
+    private timer1Start;
+    private timer1Expired;
+    private timer1Cancel;
+    /**t2 is wait for shutdown */
+    private t2Start;
+    private timer2Expired;
+    private timer2Cancel;
+    /**t3 is wait for data sack */
+    private timer3Start;
+    private timer3Restart;
+    private timer3Expired;
+    private timer3Cancel;
+    /**Re-configuration Timer */
+    private timerReconfigHandleStart;
+    private timerReconfigHandleExpired;
+    private timerReconfigCancel;
+    private heartbeatStart;
+    private heartbeatRestart;
+    private heartbeatCancel;
+    private timerHeartbeatExpired;
+    setHeartbeatInterval(interval: number): void;
+    private updateAdvancedPeerAckPoint;
+    private maybeAbandon;
+    static getCapabilities(): RTCSctpCapabilities;
+    setRemotePort(port: number): void;
+    start(remotePort?: number): Promise<void>;
+    private init;
+    private setExtensions;
+    sendChunk(chunk: Chunk): Promise<void>;
+    setState(state: SCTP_STATE): void;
+    setConnectionState(state: SCTPConnectionState): void;
+    stop(): Promise<void>;
+    abort(): Promise<void>;
+    private removeAllListeners;
+}
+export declare class InboundStream {
+    reassembly: DataChunk[];
+    streamSequenceNumber: number;
+    constructor();
+    addChunk(chunk: DataChunk): void;
+    popMessages(): Generator<[number, number, Buffer]>;
+    pruneChunks(tsn: number): number;
+}
+export declare class RTCSctpCapabilities {
+    maxMessageSize: number;
+    constructor(maxMessageSize: number);
+}
+export {};