node-rtc-connection 1.0.18 → 2.0.4

package/dist/types/ice/stun-message.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @file stun-message.ts
+ * @description STUN message codec for ICE connectivity checks (RFC 5389 / 8445).
+ * @module ice/stun-message
+ *
+ * Unlike the server-oriented stun-client.js (binding/allocate), this builds and
+ * validates the connectivity-check messages browsers require: USERNAME,
+ * MESSAGE-INTEGRITY (HMAC-SHA1 keyed by the peer's ice-pwd), FINGERPRINT
+ * (CRC-32 of the message Xored with 0x5354554e), PRIORITY, ICE-CONTROLLING/
+ * ICE-CONTROLLED, and USE-CANDIDATE.
+ */
+export declare const MAGIC_COOKIE = 554869826;
+export declare const METHOD: Readonly<{
+    BINDING: 1;
+}>;
+export declare const CLASS: Readonly<{
+    REQUEST: 0;
+    INDICATION: 16;
+    SUCCESS: 256;
+    ERROR: 272;
+}>;
+export declare const MSG_TYPE: Readonly<{
+    BINDING_REQUEST: 1;
+    BINDING_SUCCESS: 257;
+    BINDING_ERROR: 273;
+}>;
+export declare const ATTR: Readonly<{
+    MAPPED_ADDRESS: 1;
+    USERNAME: 6;
+    MESSAGE_INTEGRITY: 8;
+    ERROR_CODE: 9;
+    XOR_MAPPED_ADDRESS: 32;
+    PRIORITY: 36;
+    USE_CANDIDATE: 37;
+    FINGERPRINT: 32808;
+    ICE_CONTROLLED: 32809;
+    ICE_CONTROLLING: 32810;
+}>;
+/** A single STUN attribute pending serialization. */
+interface StunAttribute {
+    type: number;
+    value: Buffer;
+}
+/** Shape of a parsed STUN message. */
+export interface ParsedStunMessage {
+    type: number;
+    transactionId: Buffer;
+    attrs: Map<number, Buffer>;
+    raw: Buffer;
+}
+export declare function crc32(buf: Buffer): number;
+/**
+ * @class StunMessageBuilder
+ * @description Incrementally builds a STUN message, then appends
+ * MESSAGE-INTEGRITY and FINGERPRINT with the correct length pre-computation.
+ */
+export declare class StunMessageBuilder {
+    #private;
+    type: number;
+    transactionId: Buffer;
+    attrs: StunAttribute[];
+    constructor(type: number, transactionId?: Buffer);
+    addAttr(type: number, value: Buffer): this;
+    addUsername(username: string): this;
+    addPriority(priority: number): this;
+    addIceControlling(tieBreaker: Buffer): this;
+    addIceControlled(tieBreaker: Buffer): this;
+    addUseCandidate(): this;
+    addXorMappedAddress(address: string, port: number): this;
+    /**
+     * Finalize the message, appending MESSAGE-INTEGRITY (keyed by `password`)
+     * and FINGERPRINT. Both require the header length to include the attribute
+     * being computed, per RFC 5389 §15.4 / §15.5.
+     * @param {string} [password] - ICE password for MESSAGE-INTEGRITY
+     * @returns {Buffer}
+     */
+    build(password?: string): Buffer;
+}
+/**
+ * Parse a STUN message. Returns null if not a STUN message.
+ * @param {Buffer} msg
+ * @returns {null|{type:number,transactionId:Buffer,attrs:Map<number,Buffer>,raw:Buffer}}
+ */
+export declare function parse(msg: Buffer): ParsedStunMessage | null;
+/**
+ * Verify the MESSAGE-INTEGRITY of a parsed message against a password.
+ * @param {Buffer} msg - raw message
+ * @param {string} password
+ * @returns {boolean}
+ */
+export declare function verifyIntegrity(msg: Buffer, password: string): boolean;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview node-rtc-connection - WebRTC DataChannel implementation for Node.js
+ *
+ * A from-scratch, pure-Node.js implementation of WebRTC peer connections and
+ * data channels (no native dependencies). Interoperates with browsers.
+ *
+ * This implementation focuses on DataChannel functionality without media streams.
+ * Features:
+ * - ICE (Interactive Connectivity Establishment), RFC 8445
+ * - STUN/TURN support for NAT traversal
+ * - DTLS 1.2 encryption (RFC 6347)
+ * - SCTP over DTLS + DCEP for data channels (RFC 8831 / 8832)
+ * - W3C-compatible RTCPeerConnection / RTCDataChannel API
+ *
+ * @license MIT
+ * @author nmhung1210
+ */
+import ByteBufferQueue from './foundation/ByteBufferQueue';
+import RTCError from './foundation/RTCError';
+import RTCIceCandidate from './ice/RTCIceCandidate';
+import RTCCertificate from './dtls/RTCCertificate';
+import { RTCDataChannel, RTCDataChannelState } from './datachannel/RTCDataChannel';
+import { RTCSessionDescription, RTCSdpType } from './sdp/RTCSessionDescription';
+import { RTCPeerConnection, RTCSignalingState, RTCIceGatheringState, RTCPeerConnectionState } from './peerconnection/RTCPeerConnection';
+export { ByteBufferQueue, RTCError, RTCIceCandidate, RTCCertificate, RTCDataChannel, RTCDataChannelState, RTCSessionDescription, RTCSdpType, RTCPeerConnection, RTCSignalingState, RTCIceGatheringState, RTCPeerConnectionState, };
+export declare const version: string;
+export type { RTCDataChannelInit } from './datachannel/RTCDataChannel';
+export type { RTCSessionDescriptionInit } from './sdp/RTCSessionDescription';
+export type { TransportStackOptions } from './transport-stack';

package/dist/types/peerconnection/RTCPeerConnection.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @file RTCPeerConnection.ts
+ * @description WebRTC peer connection driving a real ICE/DTLS/SCTP/DCEP stack.
+ * @module peerconnection/RTCPeerConnection
+ *
+ * This orchestrates signaling (offer/answer + ICE candidate trickle) on top of
+ * src/transport-stack.ts, which implements the actual on-the-wire protocols.
+ * It interoperates with browser RTCPeerConnection for data channels.
+ */
+import { EventEmitter } from 'events';
+import RTCCertificate from '../dtls/RTCCertificate';
+import { RTCSessionDescription, RTCSessionDescriptionInit } from '../sdp/RTCSessionDescription';
+import { RTCDataChannel, RTCDataChannelInit } from '../datachannel/RTCDataChannel';
+import { TransportStack } from '../transport-stack';
+/** Configuration accepted by {@link RTCPeerConnection}. */
+export interface RTCConfiguration {
+    iceServers?: unknown[];
+    iceTransportPolicy?: 'all' | 'relay';
+    certificates?: RTCCertificate[];
+}
+export declare const RTCSignalingState: Readonly<{
+    STABLE: "stable";
+    HAVE_LOCAL_OFFER: "have-local-offer";
+    HAVE_REMOTE_OFFER: "have-remote-offer";
+    HAVE_LOCAL_PRANSWER: "have-local-pranswer";
+    HAVE_REMOTE_PRANSWER: "have-remote-pranswer";
+    CLOSED: "closed";
+}>;
+export declare const RTCIceGatheringState: Readonly<{
+    NEW: "new";
+    GATHERING: "gathering";
+    COMPLETE: "complete";
+}>;
+export declare const RTCPeerConnectionState: Readonly<{
+    NEW: "new";
+    CONNECTING: "connecting";
+    CONNECTED: "connected";
+    DISCONNECTED: "disconnected";
+    FAILED: "failed";
+    CLOSED: "closed";
+}>;
+export declare class RTCPeerConnection extends EventEmitter {
+    #private;
+    constructor(configuration?: RTCConfiguration);
+    createDataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
+    createOffer(): Promise<RTCSessionDescription>;
+    createAnswer(): Promise<RTCSessionDescription>;
+    setLocalDescription(description?: RTCSessionDescriptionInit | RTCSessionDescription): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit | string): Promise<void>;
+    getConfiguration(): RTCConfiguration;
+    setConfiguration(configuration: RTCConfiguration): void;
+    close(): void;
+    get signalingState(): string;
+    get iceGatheringState(): string;
+    get iceConnectionState(): string;
+    get connectionState(): string;
+    get localDescription(): RTCSessionDescription | null;
+    get remoteDescription(): RTCSessionDescription | null;
+    get currentLocalDescription(): RTCSessionDescription | null;
+    get currentRemoteDescription(): RTCSessionDescription | null;
+    get pendingLocalDescription(): RTCSessionDescription | null;
+    get pendingRemoteDescription(): RTCSessionDescription | null;
+    get canTrickleIceCandidates(): boolean;
+    get sctp(): TransportStack['sctp'];
+}
+/** ICE candidate init shape (subset of the W3C dictionary). */
+interface RTCIceCandidateInit {
+    candidate: string;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+    usernameFragment?: string;
+}
+export {};

package/dist/types/sctp/association.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file association.ts
+ * @description Minimal SCTP association over a datagram channel (DTLS), scoped
+ * to the WebRTC data channel profile (RFC 8831).
+ * @module sctp/association
+ *
+ * Implements the four-way INIT/INIT-ACK/COOKIE-ECHO/COOKIE-ACK setup, DATA
+ * transmit/receive with TSN tracking and SACK, ordered and unordered delivery,
+ * and reassembly of fragmented user messages. Congestion control is
+ * intentionally simple (stop-and-go style with a generous rwnd) which is
+ * adequate for control/data-channel traffic and interoperates with usrsctp
+ * (the stack browsers use).
+ *
+ * The association rides on top of a reliable-ish datagram pipe provided by
+ * DTLS; SCTP still provides framing, ordering, multiplexing and ack'ing.
+ */
+import { EventEmitter } from 'events';
+declare const SCTP_PORT = 5000;
+declare const STATE: Readonly<{
+    CLOSED: "closed";
+    COOKIE_WAIT: "cookie-wait";
+    COOKIE_ECHOED: "cookie-echoed";
+    ESTABLISHED: "established";
+}>;
+type StateValue = (typeof STATE)[keyof typeof STATE];
+/** Options for constructing an {@link SctpAssociation}. */
+export interface SctpAssociationOptions {
+    /** the DTLS client initiates SCTP (RFC 8831) */
+    isClient?: boolean;
+}
+/** A complete user message surfaced via the 'message' event. */
+export interface SctpMessage {
+    streamId: number;
+    ppid: number;
+    data: Buffer;
+}
+/**
+ * @class SctpAssociation
+ * @extends EventEmitter
+ *
+ * Events:
+ *  - 'established'             association is up
+ *  - 'message' ({streamId, ppid, data})  a complete user message arrived
+ *  - 'output' (Buffer)         an SCTP packet to hand to DTLS
+ *  - 'close'
+ */
+declare class SctpAssociation extends EventEmitter {
+    #private;
+    isClient: boolean;
+    state: StateValue;
+    /**
+     * @param {Object} opts
+     * @param {boolean} opts.isClient - the DTLS client initiates SCTP (RFC 8831)
+     */
+    constructor(opts?: SctpAssociationOptions);
+    /** Start the association (client sends INIT). */
+    start(): void;
+    /**
+     * Feed an inbound SCTP packet (decrypted from DTLS).
+     * @param {Buffer} packet
+     */
+    receivePacket(packet: Buffer): void;
+    /**
+     * Send a user message on a stream.
+     * @param {number} streamId
+     * @param {number} ppid
+     * @param {Buffer} data
+     * @param {Object} [opts]
+     * @param {boolean} [opts.unordered=false]
+     */
+    sendData(streamId: number, ppid: number, data: Buffer, opts?: {
+        unordered?: boolean;
+    }): void;
+    /** Gracefully close the association. */
+    shutdown(): void;
+}
+export { SctpAssociation, STATE, SCTP_PORT };

package/dist/types/sctp/chunks.d.ts

@@ -0,0 +1,200 @@
+/**
+ * @file chunks.ts
+ * @description SCTP common header and chunk encode/parse (RFC 4960 + RFC 8260
+ * for I-DATA is NOT used; classic DATA only). Scoped to the WebRTC profile.
+ * @module sctp/chunks
+ */
+export declare const CHUNK_TYPE: Readonly<{
+    DATA: 0;
+    INIT: 1;
+    INIT_ACK: 2;
+    SACK: 3;
+    HEARTBEAT: 4;
+    HEARTBEAT_ACK: 5;
+    ABORT: 6;
+    SHUTDOWN: 7;
+    SHUTDOWN_ACK: 8;
+    ERROR: 9;
+    COOKIE_ECHO: 10;
+    COOKIE_ACK: 11;
+    SHUTDOWN_COMPLETE: 14;
+    FORWARD_TSN: 192;
+}>;
+export declare const PARAM_TYPE: Readonly<{
+    HEARTBEAT_INFO: 1;
+    STATE_COOKIE: 7;
+    UNRECOGNIZED_PARAM: 8;
+    COOKIE_PRESERVATIVE: 9;
+    SUPPORTED_ADDR_TYPES: 11;
+    FORWARD_TSN_SUPPORTED: 49152;
+    SUPPORTED_EXTENSIONS: 32776;
+}>;
+export declare const PPID: Readonly<{
+    DCEP: 50;
+    STRING: 51;
+    BINARY: 53;
+    STRING_EMPTY: 56;
+    BINARY_EMPTY: 57;
+    STRING_PARTIAL: 54;
+    BINARY_PARTIAL: 52;
+}>;
+export interface CommonHeader {
+    srcPort: number;
+    dstPort: number;
+    verificationTag: number;
+    checksum: number;
+}
+export interface ParsedChunk {
+    type: number;
+    flags: number;
+    length: number;
+    body: Buffer;
+}
+export interface ParsedParam {
+    type: number;
+    length: number;
+    value: Buffer;
+}
+export interface InitBodyParams {
+    initiateTag: number;
+    a_rwnd: number;
+    outStreams: number;
+    inStreams: number;
+    initialTSN: number;
+}
+export interface ParsedInitBody {
+    initiateTag: number;
+    a_rwnd: number;
+    outStreams: number;
+    inStreams: number;
+    initialTSN: number;
+    params: ParsedParam[];
+}
+export interface DataBodyParams {
+    tsn: number;
+    streamId: number;
+    streamSeq: number;
+    ppid: number;
+    userData: Buffer;
+    unordered?: boolean;
+    beginning?: boolean;
+    ending?: boolean;
+}
+export interface EncodedDataBody {
+    flags: number;
+    body: Buffer;
+}
+export interface ParsedDataBody {
+    unordered: boolean;
+    beginning: boolean;
+    ending: boolean;
+    tsn: number;
+    streamId: number;
+    streamSeq: number;
+    ppid: number;
+    userData: Buffer;
+}
+export interface SackBodyParams {
+    cumulativeTSNAck: number;
+    a_rwnd: number;
+    gapBlocks?: Array<[number, number]>;
+    dupTSNs?: number[];
+}
+export interface ParsedSackBody {
+    cumulativeTSNAck: number;
+    a_rwnd: number;
+    gapBlocks: Array<[number, number]>;
+    dupTSNs: number[];
+}
+/** Round a length up to the next 4-byte boundary. */
+export declare function pad4(n: number): number;
+/**
+ * Encode the 12-byte SCTP common header (checksum left as 0; filled by crc32c).
+ * @param {number} srcPort
+ * @param {number} dstPort
+ * @param {number} verificationTag
+ * @returns {Buffer}
+ */
+export declare function encodeCommonHeader(srcPort: number, dstPort: number, verificationTag: number): Buffer;
+/**
+ * Parse the common header.
+ * @param {Buffer} packet
+ * @returns {{srcPort:number,dstPort:number,verificationTag:number,checksum:number}}
+ */
+export declare function parseCommonHeader(packet: Buffer): CommonHeader;
+/**
+ * Wrap a chunk body with the 4-byte chunk header, padded to 4 bytes.
+ * @param {number} type
+ * @param {number} flags
+ * @param {Buffer} body
+ * @returns {Buffer}
+ */
+export declare function encodeChunk(type: number, flags: number, body: Buffer): Buffer;
+/**
+ * Parse all chunks out of an SCTP packet (after the 12-byte common header).
+ * @param {Buffer} packet
+ * @returns {Array<{type:number,flags:number,length:number,body:Buffer}>}
+ */
+export declare function parseChunks(packet: Buffer): ParsedChunk[];
+/**
+ * Encode a TLV parameter, padded to 4 bytes.
+ * @param {number} type
+ * @param {Buffer} value
+ * @returns {Buffer}
+ */
+export declare function encodeParam(type: number, value: Buffer): Buffer;
+/**
+ * Parse TLV parameters from a buffer.
+ * @param {Buffer} buf
+ * @returns {Array<{type:number,length:number,value:Buffer}>}
+ */
+export declare function parseParams(buf: Buffer): ParsedParam[];
+/**
+ * Build an INIT or INIT_ACK fixed body (without parameters).
+ * @param {Object} p
+ * @param {number} p.initiateTag
+ * @param {number} p.a_rwnd - advertised receiver window
+ * @param {number} p.outStreams
+ * @param {number} p.inStreams
+ * @param {number} p.initialTSN
+ * @returns {Buffer}
+ */
+export declare function encodeInitBody({ initiateTag, a_rwnd, outStreams, inStreams, initialTSN }: InitBodyParams): Buffer;
+/**
+ * Parse an INIT/INIT_ACK body.
+ * @param {Buffer} body
+ * @returns {{initiateTag:number,a_rwnd:number,outStreams:number,inStreams:number,initialTSN:number,params:Array}}
+ */
+export declare function parseInitBody(body: Buffer): ParsedInitBody;
+/**
+ * Encode a DATA chunk body (RFC 4960 §3.3.1).
+ * @param {Object} p
+ * @param {number} p.tsn
+ * @param {number} p.streamId
+ * @param {number} p.streamSeq
+ * @param {number} p.ppid
+ * @param {Buffer} p.userData
+ * @returns {{flags:number, body:Buffer}}
+ */
+export declare function encodeDataBody({ tsn, streamId, streamSeq, ppid, userData, unordered, beginning, ending }: DataBodyParams): EncodedDataBody;
+/**
+ * Parse a DATA chunk body.
+ * @param {number} flags
+ * @param {Buffer} body
+ */
+export declare function parseDataBody(flags: number, body: Buffer): ParsedDataBody;
+/**
+ * Encode a SACK chunk body (cumulative ack only, no gap/dup for simplicity but
+ * gap blocks supported via params).
+ * @param {Object} p
+ * @param {number} p.cumulativeTSNAck
+ * @param {number} p.a_rwnd
+ * @param {Array<[number,number]>} [p.gapBlocks] - [start,end] offsets from cumAck+1
+ * @param {Array<number>} [p.dupTSNs]
+ * @returns {Buffer}
+ */
+export declare function encodeSackBody({ cumulativeTSNAck, a_rwnd, gapBlocks, dupTSNs }: SackBodyParams): Buffer;
+/**
+ * Parse a SACK chunk body.
+ */
+export declare function parseSackBody(body: Buffer): ParsedSackBody;

package/dist/types/sctp/crc32c.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file crc32c.ts
+ * @description CRC-32C (Castagnoli) checksum for SCTP packets (RFC 4960 App. B,
+ * polynomial 0x1EDC6F41), reflected input/output, used with the SCTP-specific
+ * byte ordering described in RFC 4960 §6.8 / RFC 3309.
+ * @module sctp/crc32c
+ */
+/**
+ * Compute the raw reflected CRC-32C over a buffer.
+ * @returns unsigned 32-bit
+ */
+export declare function crc32c(buf: Buffer): number;
+/**
+ * Insert the SCTP checksum into a packet. The checksum field (bytes 8..11 of
+ * the common header) is zeroed, the CRC computed over the whole packet, then
+ * written back in little-endian byte order (RFC 4960 §6.8, RFC 3309).
+ * @param packet - full SCTP packet (header + chunks)
+ * @returns the same packet, checksum filled in
+ */
+export declare function applyChecksum(packet: Buffer): Buffer;
+/**
+ * Validate the checksum of a received SCTP packet.
+ */
+export declare function verifyChecksum(packet: Buffer): boolean;

package/dist/types/sctp/datachannel-manager.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @file datachannel-manager.ts
+ * @description Bridges SCTP streams + DCEP to RTCDataChannel instances.
+ * @module sctp/datachannel-manager
+ *
+ * Responsibilities:
+ *  - Allocate SCTP stream IDs per RFC 8832 §6: the DTLS client (a=setup:active)
+ *    uses even stream IDs, the DTLS server uses odd.
+ *  - Send DATA_CHANNEL_OPEN and await DATA_CHANNEL_ACK; respond to inbound OPEN.
+ *  - Map outgoing string/binary sends to the correct PPID, and incoming PPIDs
+ *    back to string/binary, including the EMPTY variants for zero-length data.
+ */
+import { EventEmitter } from 'events';
+import type { SctpAssociation } from './association';
+import { RTCDataChannel } from '../datachannel/RTCDataChannel';
+/** Subset of RTCDataChannelInit used when opening/accepting channels. */
+interface ChannelInit {
+    ordered?: boolean;
+    maxRetransmits?: number | null;
+    maxPacketLifeTime?: number | null;
+    protocol?: string;
+}
+/** Information surfaced on the 'open-request' event for an inbound channel. */
+export interface OpenRequestInfo {
+    streamId: number;
+    label: string;
+    protocol: string;
+    ordered: boolean;
+    channelType: number;
+    reliabilityParameter: number;
+}
+declare class DataChannelManager extends EventEmitter {
+    #private;
+    /**
+     * @param {import('./association').SctpAssociation} association
+     * @param {boolean} isDtlsClient - true if we are the DTLS client (even IDs)
+     */
+    constructor(association: SctpAssociation, isDtlsClient: boolean);
+    /**
+     * Open a channel initiated locally.
+     * @param {import('../datachannel/RTCDataChannel').RTCDataChannel} channel
+     * @param {Object} init - { ordered, maxRetransmits, maxPacketLifeTime, protocol }
+     */
+    openChannel(channel: RTCDataChannel, init?: ChannelInit): void;
+    /**
+     * Register an inbound channel (created in response to 'open-request') and
+     * attach its sender.
+     */
+    acceptChannel(channel: RTCDataChannel, info: OpenRequestInfo): void;
+}
+export { DataChannelManager };

package/dist/types/sctp/dcep.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @file dcep.ts
+ * @description Data Channel Establishment Protocol (RFC 8832) message codec.
+ * @module sctp/dcep
+ *
+ * DCEP runs on PPID 50 and negotiates a data channel on an SCTP stream:
+ *   DATA_CHANNEL_OPEN (0x03)  -> DATA_CHANNEL_ACK (0x02)
+ */
+export declare const MESSAGE_TYPE: Readonly<{
+    DATA_CHANNEL_ACK: 2;
+    DATA_CHANNEL_OPEN: 3;
+}>;
+export declare const CHANNEL_TYPE: Readonly<{
+    RELIABLE: 0;
+    RELIABLE_UNORDERED: 128;
+    PARTIAL_RELIABLE_REXMIT: 1;
+    PARTIAL_RELIABLE_REXMIT_UNORDERED: 129;
+    PARTIAL_RELIABLE_TIMED: 2;
+    PARTIAL_RELIABLE_TIMED_UNORDERED: 130;
+}>;
+export interface OpenParams {
+    channelType: number;
+    priority?: number;
+    reliabilityParameter?: number;
+    label?: string;
+    protocol?: string;
+}
+export interface DecodedOpen {
+    channelType: number;
+    priority: number;
+    reliabilityParameter: number;
+    label: string;
+    protocol: string;
+    unordered: boolean;
+}
+/**
+ * Encode a DATA_CHANNEL_OPEN message.
+ * @param {Object} p
+ * @param {number} p.channelType
+ * @param {number} p.priority
+ * @param {number} p.reliabilityParameter
+ * @param {string} p.label
+ * @param {string} p.protocol
+ * @returns {Buffer}
+ */
+export declare function encodeOpen({ channelType, priority, reliabilityParameter, label, protocol }: OpenParams): Buffer;
+/**
+ * Decode a DATA_CHANNEL_OPEN message.
+ * @param {Buffer} buf
+ * @returns {Object}
+ */
+export declare function decodeOpen(buf: Buffer): DecodedOpen;
+/** Encode a DATA_CHANNEL_ACK message. */
+export declare function encodeAck(): Buffer;
+/** Return the message type of a DCEP buffer. */
+export declare function messageType(buf: Buffer): number;

package/dist/types/sdp/RTCSessionDescription.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @file RTCSessionDescription.ts
+ * @description Session Description Protocol (SDP) representation
+ * @module sdp/RTCSessionDescription
+ *
+ * Implements the W3C RTCSessionDescription interface
+ * (https://www.w3.org/TR/webrtc/#rtcsessiondescription-class).
+ */
+/**
+ * RTCSdpType - Types of session descriptions
+ * @readonly
+ * @enum {string}
+ */
+export declare const RTCSdpType: Readonly<Record<string, string>>;
+/**
+ * Session description init object.
+ */
+export interface RTCSessionDescriptionInit {
+    type?: string;
+    sdp?: string;
+}
+/**
+ * JSON representation of an RTCSessionDescription.
+ */
+export interface RTCSessionDescriptionJSON {
+    type: string | null;
+    sdp: string | null;
+}
+/**
+ * @class RTCSessionDescription
+ * @description Represents a WebRTC session description (offer/answer)
+ *
+ * @example
+ * const desc = new RTCSessionDescription({
+ *   type: 'offer',
+ *   sdp: 'v=0\r\no=- 123456 2 IN IP4 127.0.0.1\r\n...'
+ * });
+ */
+export declare class RTCSessionDescription {
+    #private;
+    /**
+     * Create an RTCSessionDescription instance.
+     * @param {Object} [init] - Session description init
+     * @param {string} [init.type] - SDP type (offer/answer/pranswer/rollback)
+     * @param {string} [init.sdp] - SDP string
+     */
+    constructor(init?: RTCSessionDescriptionInit);
+    /**
+     * Get the SDP type.
+     * @returns {string|null} SDP type
+     */
+    get type(): string | null;
+    /**
+     * Set the SDP type.
+     * @param {string} value - SDP type
+     */
+    set type(value: string | null);
+    /**
+     * Get the SDP string.
+     * @returns {string|null} SDP string
+     */
+    get sdp(): string | null;
+    /**
+     * Set the SDP string.
+     * @param {string} value - SDP string
+     */
+    set sdp(value: string | null);
+    /**
+     * Convert to JSON representation.
+     * @returns {Object} JSON representation
+     */
+    toJSON(): RTCSessionDescriptionJSON;
+}