@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/lib/rtp/rtp/headerExtension.d.ts

@@ -0,0 +1,72 @@
+import type { Extension } from './rtp.js';
+export declare const RTP_EXTENSION_URI: {
+    readonly sdesMid: "urn:ietf:params:rtp-hdrext:sdes:mid";
+    readonly sdesRTPStreamID: "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id";
+    readonly repairedRtpStreamId: "urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id";
+    readonly transportWideCC: "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01";
+    readonly absSendTime: "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time";
+    readonly dependencyDescriptor: "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension";
+    readonly audioLevelIndication: "urn:ietf:params:rtp-hdrext:ssrc-audio-level";
+    readonly videoOrientation: "urn:3gpp:video-orientation";
+};
+export type TransportWideCCPayload = number;
+export type AudioLevelIndicationPayload = {
+    v: boolean;
+    level: number;
+};
+export interface videoOrientationPayload {
+    /**
+   Camera: indicates the direction of the camera used for this video stream. It can be used by the MTSI client in
+  receiver to e.g. display the received video differently depending on the source camera.
+  0: Front-facing camera, facing the user. If camera direction is unknown by the sending MTSI client in the terminal
+  then this is the default value used.
+  1: Back-facing camera, facing away from the user.
+ */
+    c: number;
+    /**
+   F = Flip: indicates a horizontal (left-right flip) mirror operation on the video as sent on the link.
+  0: No flip operation. If the sending MTSI client in terminal does not know if a horizontal mirror operation is
+  necessary, then this is the default value used.
+  1: Horizontal flip operation
+   */
+    f: number;
+    /**
+   R1, R0 = Rotation: indicates the rotation of the video as transmitted on the link. The receiver should rotate the video to
+  compensate that rotation. E.g. a 90° Counter Clockwise rotation should be compensated by the receiver with a 90°
+  Clockwise rotation prior to displaying.
+
+    +----+----+-----------------------------------------------+------------------------------+
+  | R1 | R0 | Rotation of the video as sent on the link     | Rotation on the receiver      |
+  |    |    |                                               | before display                |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  0 |  0 | 0° rotation                                   | None                         |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  0 |  1 | 90° Counter Clockwise (CCW) rotation or 270°  | 90° Clockwise (CW) rotation  |
+  |    |    | Clockwise (CW) rotation                       |                              |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  1 |  0 | 180° CCW rotation or 180° CW rotation         | 180° CW rotation             |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  1 |  1 | 270° CCW rotation or 90° CW rotation          | 90° CCW rotation             |
+  +----+----+-----------------------------------------------+------------------------------+
+
+   */
+    r1: number;
+    r0: number;
+}
+export interface Extensions {
+    [uri: string]: any;
+}
+export declare function rtpHeaderExtensionsParser(extensions: Extension[], extIdUriMap: {
+    [id: number]: string;
+}): Extensions;
+export declare function serializeSdesMid(id: string): Buffer<ArrayBuffer>;
+export declare function serializeSdesRTPStreamID(id: string): Buffer<ArrayBuffer>;
+export declare function serializeRepairedRtpStreamId(id: string): Buffer<ArrayBuffer>;
+export declare function serializeTransportWideCC(transportSequenceNumber: number): Buffer<ArrayBuffer>;
+export declare function serializeAbsSendTime(ntpTime: bigint): Buffer<ArrayBuffer>;
+export declare function serializeAudioLevelIndication(level: number): Buffer<ArrayBufferLike>;
+export declare function deserializeString(buf: Buffer): string;
+export declare function deserializeUint16BE(buf: Buffer): number;
+export declare function deserializeAbsSendTime(buf: Buffer): any;
+export declare function deserializeAudioLevelIndication(buf: Buffer): AudioLevelIndicationPayload;
+export declare function deserializeVideoOrientation(payload: Buffer): videoOrientationPayload;

package/dist/types/lib/rtp/rtp/red/encoder.d.ts

@@ -0,0 +1,13 @@
+import { Red } from './packet.js';
+export declare class RedEncoder {
+    distance: number;
+    private cache;
+    cacheSize: number;
+    constructor(distance?: number);
+    push(payload: {
+        block: Buffer;
+        timestamp: number;
+        blockPT: number;
+    }): void;
+    build(): Red;
+}

package/dist/types/lib/rtp/rtp/red/handler.d.ts

@@ -0,0 +1,6 @@
+import { type Red, RtpPacket } from '../../index.js';
+export declare class RedHandler {
+    private readonly size;
+    private sequenceNumbers;
+    push(red: Red, base: RtpPacket): RtpPacket[];
+}

package/dist/types/lib/rtp/rtp/red/packet.d.ts

@@ -0,0 +1,26 @@
+export declare class Red {
+    header: RedHeader;
+    blocks: {
+        block: Buffer;
+        blockPT: number;
+        /**14bit */
+        timestampOffset?: number;
+    }[];
+    static deSerialize(bufferOrArrayBuffer: Buffer | ArrayBuffer): Red;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare class RedHeader {
+    fields: RedHeaderField[];
+    static deSerialize(buf: Buffer): readonly [RedHeader, number];
+    serialize(): Buffer<ArrayBuffer>;
+}
+interface RedHeaderField {
+    /**ヘッダーの最初のビットは、別のヘッダーブロックが続くかどうかを示す。 1の場合は、さらにヘッダーブロックが続き、0の場合は、これが最後のヘッダーブロックとなります。 */
+    fBit: number;
+    blockPT: number;
+    /**14bit */
+    timestampOffset?: number;
+    /**10bit */
+    blockLength?: number;
+}
+export {};

package/dist/types/lib/rtp/rtp/rtp.d.ts

@@ -0,0 +1,44 @@
+export type Extension = {
+    id: number;
+    payload: Buffer;
+};
+export declare const ExtensionProfiles: {
+    readonly OneByte: 48862;
+    readonly TwoByte: 4096;
+};
+type ExtensionProfile = (typeof ExtensionProfiles)[keyof typeof ExtensionProfiles];
+export declare class RtpHeader {
+    version: number;
+    padding: boolean;
+    paddingSize: number;
+    extension: boolean;
+    marker: boolean;
+    payloadOffset: number;
+    payloadType: number;
+    /**16bit, 初期値はランダムである必要があります*/
+    sequenceNumber: number;
+    /**32bit microsec (milli/1000), 初期値はランダムである必要があります*/
+    timestamp: number;
+    ssrc: number;
+    csrcLength: number;
+    csrc: number[];
+    extensionProfile: ExtensionProfile;
+    /**deserialize only */
+    extensionLength?: number;
+    extensions: Extension[];
+    constructor(props?: Partial<RtpHeader>);
+    static deSerialize(rawPacket: Buffer): RtpHeader;
+    get serializeSize(): number;
+    serialize(size: number): Buffer<ArrayBuffer>;
+}
+export declare class RtpPacket {
+    header: RtpHeader;
+    payload: Buffer;
+    constructor(header: RtpHeader, payload: Buffer);
+    get serializeSize(): number;
+    clone(): RtpPacket;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(buf: Buffer): RtpPacket;
+    clear(): void;
+}
+export {};

package/dist/types/lib/rtp/rtp/rtx.d.ts

@@ -0,0 +1,3 @@
+import { RtpPacket } from './rtp.js';
+export declare function unwrapRtx(rtx: RtpPacket, payloadType: number, ssrc: number): RtpPacket;
+export declare function wrapRtx(packet: RtpPacket, payloadType: number, sequenceNumber: number, ssrc: number): RtpPacket;

package/dist/types/lib/rtp/srtp/cipher/ctr.d.ts

@@ -0,0 +1,16 @@
+import { CipherAesBase } from './index.js';
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { RtpHeader } from '../../rtp/rtp.js';
+export declare class CipherAesCtr extends CipherAesBase {
+    private srtpSessionAuthTag;
+    private srtcpSessionAuthTag;
+    readonly authTagLength = 10;
+    constructor(srtpSessionKey: Buffer, srtpSessionSalt: Buffer, srtcpSessionKey: Buffer, srtcpSessionSalt: Buffer, srtpSessionAuthTag: Buffer, srtcpSessionAuthTag: Buffer);
+    encryptRtp(header: RtpHeader, payload: Buffer, rolloverCounter: number): Buffer<ArrayBuffer>;
+    decryptRtp(cipherText: Buffer, rolloverCounter: number, header?: RtpHeader): [Buffer, RtpHeader];
+    encryptRTCP(rtcpPacket: Buffer, srtcpIndex: number): Buffer;
+    decryptRTCP(encrypted: Buffer): [Buffer, RtcpHeader];
+    generateSrtcpAuthTag(buf: Buffer): Buffer<ArrayBuffer>;
+    generateCounter(sequenceNumber: number, rolloverCounter: number, ssrc: number, sessionSalt: Buffer): Buffer<ArrayBuffer>;
+    generateSrtpAuthTag(roc: number, ...buffers: Buffer[]): Buffer<ArrayBuffer>;
+}

package/dist/types/lib/rtp/srtp/cipher/gcm.d.ts

@@ -0,0 +1,17 @@
+import { CipherAesBase } from './index.js';
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { RtpHeader } from '../../rtp/rtp.js';
+export declare class CipherAesGcm extends CipherAesBase {
+    readonly aeadAuthTagLen = 16;
+    readonly rtpIvWriter: (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+    readonly rtcpIvWriter: (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+    readonly aadWriter: (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+    constructor(srtpSessionKey: Buffer, srtpSessionSalt: Buffer, srtcpSessionKey: Buffer, srtcpSessionSalt: Buffer);
+    encryptRtp(header: RtpHeader, payload: Buffer, rolloverCounter: number): Buffer<ArrayBuffer>;
+    decryptRtp(cipherText: Buffer, rolloverCounter: number, header?: RtpHeader): [Buffer, RtpHeader];
+    encryptRTCP(rtcpPacket: Buffer, srtcpIndex: number): Buffer;
+    decryptRTCP(encrypted: Buffer): [Buffer, RtcpHeader];
+    private rtpInitializationVector;
+    private rtcpInitializationVector;
+    private rtcpAdditionalAuthenticatedData;
+}

package/dist/types/lib/rtp/srtp/cipher/index.d.ts

@@ -0,0 +1,13 @@
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { RtpHeader } from '../../rtp/rtp.js';
+export declare abstract class CipherAesBase {
+    srtpSessionKey: Buffer;
+    srtpSessionSalt: Buffer;
+    srtcpSessionKey: Buffer;
+    srtcpSessionSalt: Buffer;
+    constructor(srtpSessionKey: Buffer, srtpSessionSalt: Buffer, srtcpSessionKey: Buffer, srtcpSessionSalt: Buffer);
+    encryptRtp(_header: RtpHeader, _payload: Buffer, _rolloverCounter: number): Buffer;
+    decryptRtp(_cipherText: Buffer, _rolloverCounter: number, _header?: RtpHeader): [Buffer, RtpHeader];
+    encryptRTCP(_rawRtcp: Buffer, _srtcpIndex: number): Buffer;
+    decryptRTCP(_encrypted: Buffer): [Buffer, RtcpHeader];
+}

package/dist/types/lib/rtp/srtp/const.d.ts

@@ -0,0 +1,6 @@
+export declare const ProtectionProfileAes128CmHmacSha1_80: 1;
+export declare const ProtectionProfileAeadAes128Gcm: 7;
+export declare const Profiles: readonly [1, 7];
+export type SrtpProfile = (typeof Profiles)[number];
+export declare const keyLength: (profile: SrtpProfile) => number;
+export declare const saltLength: (profile: SrtpProfile) => 12 | 14;

package/dist/types/lib/rtp/srtp/context/context.d.ts

@@ -0,0 +1,45 @@
+import { createHmac } from 'node:crypto';
+import type { CipherAesBase } from '../cipher/index.js';
+import { type SrtpProfile } from '../const.js';
+/** AES-128-ECB single-block encrypt for SRTP KDF (no padding). */
+export declare function aes128EcbEncrypt(key: Buffer, plaintext: Buffer): Buffer;
+export declare class Context {
+    masterKey: Buffer;
+    masterSalt: Buffer;
+    profile: SrtpProfile;
+    srtpSSRCStates: {
+        [ssrc: number]: SrtpSsrcState;
+    };
+    srtpSessionKey: Buffer;
+    srtpSessionSalt: Buffer;
+    srtpSessionAuthTag: Buffer;
+    srtpSessionAuth: ReturnType<typeof createHmac>;
+    srtcpSSRCStates: {
+        [ssrc: number]: SrtcpSSRCState;
+    };
+    srtcpSessionKey: Buffer;
+    srtcpSessionSalt: Buffer;
+    srtcpSessionAuthTag: Buffer;
+    srtcpSessionAuth: ReturnType<typeof createHmac>;
+    cipher: CipherAesBase;
+    constructor(masterKey: Buffer, masterSalt: Buffer, profile: SrtpProfile);
+    generateSessionKey(label: number): Buffer<ArrayBufferLike>;
+    generateSessionSalt(label: number): Buffer<ArrayBufferLike>;
+    generateSessionAuthTag(label: number): Buffer<ArrayBuffer>;
+    getSrtpSsrcState(ssrc: number): SrtpSsrcState;
+    getSrtcpSsrcState(ssrc: number): SrtcpSSRCState;
+    updateRolloverCount(sequenceNumber: number, s: SrtpSsrcState): void;
+    generateSrtpAuthTag(buf: Buffer, roc: number): Buffer<ArrayBuffer>;
+    index(ssrc: number): number;
+    setIndex(ssrc: number, index: number): void;
+}
+export interface SrtpSsrcState {
+    ssrc: number;
+    rolloverCounter: number;
+    rolloverHasProcessed?: boolean;
+    lastSequenceNumber: number;
+}
+export type SrtcpSSRCState = {
+    srtcpIndex: number;
+    ssrc: number;
+};

package/dist/types/lib/rtp/srtp/context/srtcp.d.ts

@@ -0,0 +1,8 @@
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { SrtpProfile } from '../const.js';
+import { Context } from './context.js';
+export declare class SrtcpContext extends Context {
+    constructor(masterKey: Buffer, masterSalt: Buffer, profile: SrtpProfile);
+    encryptRTCP(rawRtcp: Buffer): Buffer<ArrayBufferLike>;
+    decryptRTCP(encrypted: Buffer): [Buffer, RtcpHeader];
+}

package/dist/types/lib/rtp/srtp/context/srtp.d.ts

@@ -0,0 +1,9 @@
+import type { RtpHeader } from '../../rtp/rtp.js';
+import { type SrtpProfile } from '../const.js';
+import { Context } from './context.js';
+export declare class SrtpContext extends Context {
+    constructor(masterKey: Buffer, masterSalt: Buffer, profile: SrtpProfile);
+    encryptRtp(payload: Buffer, header: RtpHeader): Buffer<ArrayBufferLike>;
+    decryptRtp(cipherText: Buffer): [Buffer, RtpHeader];
+    private get rtpAuthTagLength();
+}

package/dist/types/lib/rtp/srtp/error.d.ts

@@ -0,0 +1,3 @@
+export declare class SrtpAuthenticationError extends Error {
+    constructor(message: string);
+}

package/dist/types/lib/rtp/srtp/packet.d.ts

@@ -0,0 +1,5 @@
+import { RtcpHeader } from '../rtcp/header.js';
+import { RtpHeader } from '../rtp/rtp.js';
+export declare function parseSrtpRtpHeader(packet: Buffer, authTagLength: number, message?: string): RtpHeader;
+export declare function parseSrtcpHeader(packet: Buffer, authTagLength: number, srtcpIndexSize: number, message?: string): RtcpHeader;
+export declare function finalizeSrtpRtpHeader(header: RtpHeader, packet: Buffer, message?: string): RtpHeader;

package/dist/types/lib/rtp/srtp/session.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from './context/context.js';
+export type SessionKeys = {
+    localMasterKey: Buffer;
+    localMasterSalt: Buffer;
+    remoteMasterKey: Buffer;
+    remoteMasterSalt: Buffer;
+};
+export type Config = {
+    keys: SessionKeys;
+    profile: number;
+};
+export declare class Session<T extends Context> {
+    private ContextCls;
+    localContext: T;
+    remoteContext: T;
+    onData?: (buf: Buffer) => void;
+    constructor(ContextCls: any);
+    start(localMasterKey: Buffer, localMasterSalt: Buffer, remoteMasterKey: Buffer, remoteMasterSalt: Buffer, profile: number): void;
+}

package/dist/types/lib/rtp/srtp/srtcp.d.ts

@@ -0,0 +1,8 @@
+import { SrtcpContext } from './context/srtcp.js';
+import { type Config, Session } from './session.js';
+export declare class SrtcpSession extends Session<SrtcpContext> {
+    config: Config;
+    constructor(config: Config);
+    decrypt: (buf: Buffer) => Buffer<ArrayBufferLike>;
+    encrypt(rawRtcp: Buffer): Buffer<ArrayBufferLike>;
+}

package/dist/types/lib/rtp/srtp/srtp.d.ts

@@ -0,0 +1,9 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import { SrtpContext } from './context/srtp.js';
+import { type Config, Session } from './session.js';
+export declare class SrtpSession extends Session<SrtpContext> {
+    config: Config;
+    constructor(config: Config);
+    decrypt: (buf: Buffer) => Buffer<ArrayBufferLike>;
+    encrypt(payload: Buffer, header: RtpHeader): Buffer<ArrayBufferLike>;
+}

package/dist/types/lib/rtp/transport.d.ts

@@ -0,0 +1,15 @@
+import type { RemoteInfo, Socket } from 'node:dgram';
+export interface Transport {
+    onData?: (buf: Buffer) => void;
+    send: (buf: Buffer) => void;
+    close: () => void;
+}
+export declare class UdpTransport implements Transport {
+    private upd;
+    private rinfo;
+    constructor(upd: Socket, rinfo: Partial<RemoteInfo>);
+    onData?: (buf: Buffer) => void;
+    send(buf: Buffer): void;
+    close(): void;
+}
+export declare const createUdpTransport: (socket: Socket, rinfo?: Partial<RemoteInfo>) => UdpTransport;

package/dist/types/lib/rtp/util.d.ts

@@ -0,0 +1,11 @@
+import { RtpPacket } from './rtp/rtp.js';
+export declare class RtpBuilder {
+    private props;
+    sequenceNumber: number;
+    timestamp: number;
+    constructor(props: {
+        between: number;
+        clockRate: number;
+    });
+    create(payload: Buffer): RtpPacket;
+}

package/dist/types/lib/sctp/chunk.d.ts

@@ -0,0 +1,164 @@
+export declare const SCTP_PADDING_MULTIPLE = 4;
+export declare const SCTP_COMMON_HEADER_SIZE = 12;
+export declare const SCTP_CHUNK_HEADER_SIZE = 4;
+export declare const SCTP_DATA_FIXED_HEADER_SIZE = 12;
+export declare const SCTP_DATA_CHUNK_HEADER_SIZE: number;
+export declare class Chunk {
+    flags: number;
+    private _body;
+    get body(): Buffer | undefined;
+    set body(value: Buffer | undefined);
+    static type: number;
+    constructor(flags?: number, _body?: Buffer | undefined);
+    get type(): number;
+    get bytes(): Buffer<ArrayBuffer>;
+}
+export declare class BaseInitChunk extends Chunk {
+    flags: number;
+    initiateTag: number;
+    advertisedRwnd: number;
+    outboundStreams: number;
+    inboundStreams: number;
+    initialTsn: number;
+    params: [number, Buffer][];
+    constructor(flags?: number, body?: Buffer);
+    get body(): Buffer<ArrayBuffer>;
+}
+export declare class InitChunk extends BaseInitChunk {
+    static type: 1;
+    get type(): 1;
+}
+export declare class InitAckChunk extends BaseInitChunk {
+    static type: 2;
+    get type(): 2;
+}
+export declare class ReConfigChunk extends BaseInitChunk {
+    static type: 130;
+    get type(): 130;
+}
+export declare class ForwardTsnChunk extends Chunk {
+    flags: number;
+    static type: 192;
+    streams: [number, number][];
+    cumulativeTsn: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get type(): 192;
+    set body(_: Buffer);
+    get body(): Buffer;
+}
+export declare class DataChunk extends Chunk {
+    flags: number;
+    static type: 0;
+    get type(): 0;
+    tsn: number;
+    streamId: number;
+    streamSeqNum: number;
+    protocol: number;
+    userData: Buffer;
+    abandoned: boolean;
+    acked: boolean;
+    misses: number;
+    retransmit: boolean;
+    sentCount: number;
+    bookSize: number;
+    expiry?: number;
+    maxRetransmits?: number;
+    sentTime?: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get bytes(): Buffer<ArrayBuffer>;
+}
+export declare class CookieEchoChunk extends Chunk {
+    static type: 10;
+    get type(): 10;
+}
+export declare class CookieAckChunk extends Chunk {
+    static type: 11;
+    get type(): 11;
+}
+export declare class BaseParamsChunk extends Chunk {
+    flags: number;
+    params: [number, Buffer][];
+    constructor(flags?: number, body?: Buffer | undefined);
+    get body(): Buffer<ArrayBuffer>;
+}
+export declare class AbortChunk extends BaseParamsChunk {
+    static type: 6;
+    get type(): 6;
+}
+export declare class ErrorChunk extends BaseParamsChunk {
+    static type: 9;
+    static readonly CODE: {
+        readonly InvalidStreamIdentifier: 1;
+        readonly MissingMandatoryParameter: 2;
+        readonly StaleCookieError: 3;
+        readonly OutofResource: 4;
+        readonly UnresolvableAddress: 5;
+        readonly UnrecognizedChunkType: 6;
+        readonly InvalidMandatoryParameter: 7;
+        readonly UnrecognizedParameters: 8;
+        readonly NoUserData: 9;
+        readonly CookieReceivedWhileShuttingDown: 10;
+        readonly RestartofanAssociationwithNewAddresses: 11;
+        readonly UserInitiatedAbort: 12;
+        readonly ProtocolViolation: 13;
+    };
+    get type(): 9;
+    get descriptions(): {
+        name: string | undefined;
+        body: Buffer<ArrayBufferLike>;
+    }[];
+}
+export declare class HeartbeatChunk extends BaseParamsChunk {
+    static type: 4;
+    get type(): 4;
+}
+export declare class HeartbeatAckChunk extends BaseParamsChunk {
+    static type: 5;
+    get type(): 5;
+}
+export declare class ReconfigChunk extends BaseParamsChunk {
+    static type: 130;
+    get type(): 130;
+}
+export declare class SackChunk extends Chunk {
+    flags: number;
+    static type: number;
+    get type(): number;
+    gaps: [number, number][];
+    duplicates: number[];
+    cumulativeTsn: number;
+    advertisedRwnd: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get bytes(): Buffer<ArrayBuffer>;
+}
+export declare class ShutdownChunk extends Chunk {
+    flags: number;
+    static type: number;
+    get type(): number;
+    cumulativeTsn: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get body(): Buffer<ArrayBuffer>;
+}
+export declare class ShutdownAckChunk extends Chunk {
+    static type: number;
+    get type(): number;
+}
+export declare class ShutdownCompleteChunk extends Chunk {
+    static type: number;
+    get type(): number;
+}
+export declare const CHUNK_BY_TYPE: {
+    [key: string]: typeof Chunk;
+};
+export declare function decodeParams(body: Buffer): [number, Buffer][];
+export declare function parsePacket(data: Buffer): [number, number, number, Chunk[]];
+/**
+ * One SCTP packet with several chunks (bundling, RFC 9260 section 6.10): the control chunks go first. The packet is
+ * written in one buffer, DATA chunks without an intermediate copy
+ */
+export declare function serializePackets(sourcePort: number, destinationPort: number, verificationTag: number, chunks: Chunk[]): Buffer;
+/**
+ * The length of a chunk in a packet, padding included
+ */
+export declare function chunkWireLength(chunk: Chunk): number;
+export declare function serializePacket(sourcePort: number, destinationPort: number, verificationTag: number, chunk: Chunk): Buffer<ArrayBufferLike>;

package/dist/types/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/types/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/types/lib/sctp/imports/common.d.ts

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

package/dist/types/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/types/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 {};