@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/lib/peer/utils.d.ts

@@ -0,0 +1,73 @@
+import { type Address } from './imports/common.js';
+import type { TurnServerOptions } from './imports/ice.js';
+import { type MediaDirection } from './media/rtpTransceiver.js';
+import { MediaStreamTrack } from './media/track.js';
+import type { RTCIceServer } from './peerConnection.js';
+export declare function fingerprint(file: Buffer, hashName: string): any;
+export declare function normalizeFingerprintAlgorithm(algorithm: string): string;
+export declare function normalizeFingerprintValue(value: string): string;
+export declare function isDtls(buf: Buffer): boolean;
+export declare function reverseSimulcastDirection(dir: 'recv' | 'send'): "send" | "recv";
+export declare const andDirection: (a: MediaDirection, b: MediaDirection) => "sendonly" | "sendrecv" | "recvonly" | "inactive";
+export declare function reverseDirection(dir: MediaDirection): MediaDirection;
+export declare const milliTime: () => number;
+export declare const microTime: () => bigint;
+export declare const timestampSeconds: () => number;
+/**
+ * The time now as an NTP timestamp (RFC 5905): 32 bits of seconds since 1900, then 32 bits of fraction of a second
+ */
+export declare const ntpTime: (epochMs?: number) => bigint;
+/**
+ * The abs-send-time header extension of a time: the 6 low bits of the seconds and the 18 high bits of the fraction of
+ * its NTP timestamp, without the bigints of ntpTime() (it is computed for each packet)
+ * @param epochMs The time, in milliseconds since the Unix epoch.
+ */
+export declare const absSendTimeOf: (epochMs: number) => Buffer;
+/**
+ * The time of an NTP timestamp, in milliseconds since the Unix epoch
+ * @param ntp
+ */
+export declare const ntpTimeToEpochMs: (ntp: bigint) => number;
+/**
+ * https://datatracker.ietf.org/doc/html/rfc3550#section-4
+ * @param ntp
+ * @returns 32bit
+ */
+export declare const compactNtp: (ntp: bigint) => number;
+export declare function parseIceServers(iceServers: RTCIceServer[]): {
+    stunServer?: Address;
+    turnServer?: Address;
+    turnUsername?: string;
+    turnPassword?: string;
+    turnTransport?: "udp" | "tcp" | "tls";
+    stunServers: Address[];
+    turnServers: TurnServerOptions[];
+};
+export declare function resolveTurnTransport({ configuredTurnTransport, forceTurnTCP, parsedTurnTransport }: {
+    parsedTurnTransport?: 'udp' | 'tcp' | 'tls';
+    configuredTurnTransport?: 'udp' | 'tcp' | 'tls';
+    forceTurnTCP: boolean;
+}): "tls" | "tcp" | "udp" | undefined;
+/**
+ *
+ * @param signatureHash
+ * @param namedCurveAlgorithm necessary when use ecdsa
+ */
+export declare const createSelfSignedCertificate: (signatureHash: import("./imports/dtls.js").SignatureHash, _namedCurveAlgorithm?: import("./imports/dtls.js").NamedCurveAlgorithms) => Promise<{
+    certPem: string;
+    keyPem: string;
+    signatureHash: import("./imports/dtls.js").SignatureHash;
+}>;
+export declare class MediaStreamTrackFactory {
+    static rtpSource({ port, kind, cb }: {
+        port?: number;
+        kind: 'audio' | 'video';
+        cb?: (buf: Buffer) => Buffer;
+    }): Promise<readonly [MediaStreamTrack, number, () => void]>;
+}
+/**
+ * Merge two objects. If a property value in the source object is undefined or
+ * when casted is equal to undefined (== undefined), then it will not overwrite
+ * the value of the property in the destination object.
+ */
+export declare const deepMerge: <T>(dst: T, src: T) => T;

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

@@ -0,0 +1,56 @@
+import type { RtpHeader } from '../index.js';
+export declare class AV1RtpPayload {
+    /**
+   * RtpStartsWithFragment
+   * MUST be set to 1 if the first OBU element is an OBU fragment that is a continuation of an OBU fragment from the previous packet, and MUST be set to 0 otherwise.
+   */
+    zBit_RtpStartsWithFragment: number;
+    /**
+   * RtpEndsWithFragment
+   * MUST be set to 1 if the last OBU element is an OBU fragment that will continue in the next packet, and MUST be set to 0 otherwise.
+   */
+    yBit_RtpEndsWithFragment: number;
+    /**
+   * RtpNumObus
+   * two bit field that describes the number of OBU elements in the packet. This field MUST be set equal to 0 or equal to the number of OBU elements contained in the packet. If set to 0, each OBU element MUST be preceded by a length field.
+   */
+    w_RtpNumObus: number;
+    /**
+   * RtpStartsNewCodedVideoSequence
+   * MUST be set to 1 if the packet is the first packet of a coded video sequence, and MUST be set to 0 otherwise.
+   */
+    nBit_RtpStartsNewCodedVideoSequence: number;
+    obu_or_fragment: {
+        data: Buffer;
+        isFragment: boolean;
+    }[];
+    static deSerialize: (buf: Buffer) => AV1RtpPayload;
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    static getFrame(payloads: AV1RtpPayload[]): Buffer<ArrayBuffer>;
+}
+export declare class AV1Obu {
+    obu_forbidden_bit: number;
+    obu_type: OBU_TYPE;
+    obu_extension_flag: number;
+    obu_has_size_field: number;
+    obu_reserved_1bit: number;
+    payload: Buffer;
+    static deSerialize(buf: Buffer): AV1Obu;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare function leb128decode(buf: Buffer): number[];
+declare const OBU_TYPES: {
+    readonly 0: "Reserved";
+    readonly 1: "OBU_SEQUENCE_HEADER";
+    readonly 2: "OBU_TEMPORAL_DELIMITER";
+    readonly 3: "OBU_FRAME_HEADER";
+    readonly 4: "OBU_TILE_GROUP";
+    readonly 5: "OBU_METADATA";
+    readonly 6: "OBU_FRAME";
+    readonly 7: "OBU_REDUNDANT_FRAME_HEADER";
+    readonly 8: "OBU_TILE_LIST";
+    readonly 15: "OBU_PADDING";
+};
+type OBU_TYPE = (typeof OBU_TYPES)[keyof typeof OBU_TYPES];
+export {};

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

@@ -0,0 +1,8 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+export declare abstract class DePacketizerBase {
+    payload: Buffer;
+    fragment?: Buffer;
+    static deSerialize(_buf: Buffer, _fragment?: Buffer): DePacketizerBase;
+    static isDetectedFinalPacketInSequence(_header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+}

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

@@ -0,0 +1,32 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class H264RtpPayload implements DePacketizerBase {
+    /**forbidden_zero_bit */
+    f: number;
+    /**nal_ref_idc */
+    nri: number;
+    /**nal_unit_types */
+    nalUnitType: number;
+    /**start of a fragmented NAL unit */
+    s: number;
+    /**end of a fragmented NAL unit */
+    e: number;
+    r: number;
+    nalUnitPayloadType: number;
+    payload: Buffer;
+    fragment?: Buffer;
+    static deSerialize(buf: Buffer, fragment?: Buffer): H264RtpPayload;
+    private static packaging;
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    get isPartitionHead(): boolean;
+}
+export declare const NalUnitType: {
+    readonly idrSlice: 5;
+    readonly stap_a: 24;
+    readonly stap_b: 25;
+    readonly mtap16: 26;
+    readonly mtap24: 27;
+    readonly fu_a: 28;
+    readonly fu_b: 29;
+};

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

@@ -0,0 +1,16 @@
+import type { RtpPacket } from '../rtp/rtp.js';
+export * from './av1.js';
+export * from './base.js';
+export * from './h264.js';
+export * from './opus.js';
+export * from './vp8.js';
+export * from './vp9.js';
+export declare function dePacketizeRtpPackets(codec: DepacketizerCodec, packets: RtpPacket[], frameFragmentBuffer?: Buffer): {
+    isKeyframe: boolean;
+    data: Buffer;
+    sequence: number;
+    timestamp: number;
+    frameFragmentBuffer?: Buffer;
+};
+export declare const depacketizerCodecs: readonly ["MPEG4/ISO/AVC", "VP8", "VP9", "OPUS", "AV1"];
+export type DepacketizerCodec = (typeof depacketizerCodecs)[number] | Lowercase<(typeof depacketizerCodecs)[number]>;

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

@@ -0,0 +1,5 @@
+/**
+ * Unsigned LEB128 encoder（package-private）。
+ * `codec/index.ts` の public barrel からは re-export しない。decode は `av1.ts` 側の公開 API を維持する。
+ */
+export declare function leb128encode(value: number): Buffer;

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

@@ -0,0 +1,9 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class OpusRtpPayload implements DePacketizerBase {
+    payload: Buffer;
+    static deSerialize(buf: Buffer): OpusRtpPayload;
+    static isDetectedFinalPacketInSequence(_header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    static createCodecPrivate(samplingFrequency?: number): Buffer<ArrayBuffer>;
+}

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

@@ -0,0 +1,27 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class Vp8RtpPayload implements DePacketizerBase {
+    xBit: number;
+    nBit: number;
+    sBit: number;
+    pid: number;
+    iBit?: number;
+    lBit?: number;
+    tBit?: number;
+    kBit?: number;
+    mBit?: number;
+    pictureId?: number;
+    payload: Buffer;
+    size0: number;
+    hBit?: number;
+    ver?: number;
+    pBit?: number;
+    size1: number;
+    size2: number;
+    static deSerialize(buf: Buffer): Vp8RtpPayload;
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    get isPartitionHead(): boolean;
+    get payloadHeaderExist(): boolean;
+    get size(): number;
+}

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

@@ -0,0 +1,46 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class Vp9RtpPayload implements DePacketizerBase {
+    /**Picture ID (PID) present */
+    iBit: number;
+    /**Inter-picture predicted frame */
+    pBit: number;
+    /**Layer indices present */
+    lBit: number;
+    /**Flexible mode */
+    fBit: number;
+    /**Start of a frame */
+    bBit: number;
+    /**End of a frame */
+    eBit: number;
+    /**Scalability structure */
+    vBit: number;
+    zBit: number;
+    m?: number;
+    pictureId?: number;
+    tid?: number;
+    u?: number;
+    sid?: number;
+    /**inter_layer_predicted */
+    d?: number;
+    tl0PicIdx?: number;
+    pDiff: number[];
+    n_s?: number;
+    y?: number;
+    g?: number;
+    width: number[];
+    height: number[];
+    n_g: number;
+    pgT: number[];
+    pgU: number[];
+    pgP_Diff: number[][];
+    payload: Buffer;
+    static deSerialize(buf: Buffer): Vp9RtpPayload;
+    static parseRtpPayload(buf: Buffer): {
+        offset: number;
+        p: Vp9RtpPayload;
+    };
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    get isPartitionHead(): boolean | 0;
+}

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

@@ -0,0 +1 @@
+export declare const MTU = 1200;

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

@@ -0,0 +1,8 @@
+export declare function enumerate<T>(arr: T[]): [number, T][];
+export declare function growBufferSize(buf: Buffer, size: number): Buffer<ArrayBuffer>;
+export declare function Int(v: number): number;
+export declare const timer: {
+    setTimeout: (callback: (_: void) => void, delay?: number | undefined) => () => void;
+    setInterval: (callback: (_: void) => void, delay?: number | undefined) => () => void;
+};
+export declare function isMedia(buf: Buffer): boolean;

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

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

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

@@ -0,0 +1,25 @@
+export * from './srtp/const.js';
+export * from '../common/index.js';
+export * from './codec/index.js';
+export * from './helper.js';
+export * from './rtcp/header.js';
+export * from './rtcp/psfb/index.js';
+export * from './rtcp/psfb/pictureLossIndication.js';
+export * from './rtcp/psfb/remb.js';
+export * from './rtcp/rr.js';
+export * from './rtcp/rtcp.js';
+export * from './rtcp/rtpfb/index.js';
+export * from './rtcp/rtpfb/nack.js';
+export * from './rtcp/rtpfb/twcc.js';
+export * from './rtcp/sdes.js';
+export * from './rtcp/sr.js';
+export * from './rtp/headerExtension.js';
+export * from './rtp/red/encoder.js';
+export * from './rtp/red/handler.js';
+export * from './rtp/red/packet.js';
+export * from './rtp/rtp.js';
+export * from './rtp/rtx.js';
+export * from './srtp/srtcp.js';
+export * from './srtp/srtp.js';
+export * from './srtp/error.js';
+export * from './util.js';

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

@@ -0,0 +1,13 @@
+export declare const RTCP_HEADER_SIZE = 4;
+export declare class RtcpHeader {
+    version: number;
+    padding: boolean;
+    count: number;
+    type: number;
+    /**このパケットの長さは、ヘッダーと任意のパディングを含む32ビットワードから 1を引いたものである */
+    length: number;
+    constructor(props?: Partial<RtcpHeader>);
+    static serialize(type: number, count: number, payload: Buffer, length: number): Buffer<ArrayBuffer>;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(buf: Buffer): RtcpHeader;
+}

package/dist/types/lib/rtp/rtcp/psfb/fullIntraRequest.d.ts

@@ -0,0 +1,16 @@
+type firEntry = {
+    ssrc: number;
+    sequenceNumber: number;
+};
+export declare class FullIntraRequest {
+    static count: number;
+    count: number;
+    senderSsrc: number;
+    mediaSsrc: number;
+    fir: firEntry[];
+    constructor(props?: Partial<FullIntraRequest>);
+    get length(): number;
+    static deSerialize(data: Buffer): FullIntraRequest;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export {};

package/dist/types/lib/rtp/rtcp/psfb/index.d.ts

@@ -0,0 +1,14 @@
+import { RtcpHeader } from '../header.js';
+import { FullIntraRequest } from './fullIntraRequest.js';
+import { PictureLossIndication } from './pictureLossIndication.js';
+import { ReceiverEstimatedMaxBitrate } from './remb.js';
+type Feedback = FullIntraRequest | PictureLossIndication | ReceiverEstimatedMaxBitrate;
+export declare class RtcpPayloadSpecificFeedback {
+    static readonly type = 206;
+    readonly type = 206;
+    feedback: Feedback;
+    constructor(props?: Partial<RtcpPayloadSpecificFeedback>);
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer, header: RtcpHeader): RtcpPayloadSpecificFeedback;
+}
+export {};

package/dist/types/lib/rtp/rtcp/psfb/pictureLossIndication.d.ts

@@ -0,0 +1,10 @@
+export declare class PictureLossIndication {
+    static count: number;
+    count: number;
+    length: number;
+    senderSsrc: number;
+    mediaSsrc: number;
+    constructor(props?: Partial<PictureLossIndication>);
+    static deSerialize(data: Buffer): PictureLossIndication;
+    serialize(): Buffer<ArrayBuffer>;
+}

package/dist/types/lib/rtp/rtcp/psfb/remb.d.ts

@@ -0,0 +1,16 @@
+export declare class ReceiverEstimatedMaxBitrate {
+    static count: number;
+    length: number;
+    count: number;
+    senderSsrc: number;
+    mediaSsrc: number;
+    readonly uniqueID: string;
+    ssrcNum: number;
+    brExp: number;
+    brMantissa: number;
+    bitrate: bigint;
+    ssrcFeedbacks: number[];
+    constructor(props?: Partial<ReceiverEstimatedMaxBitrate>);
+    static deSerialize(data: Buffer): ReceiverEstimatedMaxBitrate;
+    serialize(): Buffer<ArrayBuffer>;
+}

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

@@ -0,0 +1,32 @@
+export declare class RtcpRrPacket {
+    ssrc: number;
+    reports: RtcpReceiverInfo[];
+    static readonly type = 201;
+    readonly type = 201;
+    constructor(props?: Partial<RtcpRrPacket>);
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer, count: number): RtcpRrPacket;
+}
+export declare class RtcpReceiverInfo {
+    ssrc: number;
+    fractionLost: number;
+    packetsLost: number;
+    highestSequence: number;
+    jitter: number;
+    /**last SR */
+    lsr: number;
+    /**delay since last SR */
+    dlsr: number;
+    constructor(props?: Partial<RtcpReceiverInfo>);
+    toJSON(): {
+        ssrc: number;
+        fractionLost: number;
+        packetsLost: number;
+        highestSequence: number;
+        jitter: number;
+        lsr: number;
+        dlsr: number;
+    };
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): RtcpReceiverInfo;
+}

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

@@ -0,0 +1,10 @@
+import { RtcpPayloadSpecificFeedback } from './psfb/index.js';
+import { RtcpRrPacket } from './rr.js';
+import { RtcpTransportLayerFeedback } from './rtpfb/index.js';
+import { RtcpSourceDescriptionPacket } from './sdes.js';
+import { RtcpSrPacket } from './sr.js';
+export type RtcpPacket = RtcpRrPacket | RtcpSrPacket | RtcpPayloadSpecificFeedback | RtcpSourceDescriptionPacket | RtcpTransportLayerFeedback;
+export declare class RtcpPacketConverter {
+    static deSerialize(data: Buffer): RtcpPacket[];
+}
+export declare function isRtcp(buf: Buffer): boolean;

package/dist/types/lib/rtp/rtcp/rtpfb/const.d.ts

@@ -0,0 +1 @@
+export declare const RtcpTransportLayerFeedbackType = 205;

package/dist/types/lib/rtp/rtcp/rtpfb/index.d.ts

@@ -0,0 +1,14 @@
+import type { RtcpHeader } from '../header.js';
+import { GenericNack } from './nack.js';
+import { TransportWideCC } from './twcc.js';
+type Feedback = GenericNack | TransportWideCC;
+export declare class RtcpTransportLayerFeedback {
+    static readonly type = 205;
+    readonly type = 205;
+    feedback: Feedback;
+    header: RtcpHeader;
+    constructor(props?: Partial<RtcpTransportLayerFeedback>);
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer, header: RtcpHeader): RtcpTransportLayerFeedback;
+}
+export {};

package/dist/types/lib/rtp/rtcp/rtpfb/nack.d.ts

@@ -0,0 +1,17 @@
+import { RtcpHeader } from '../header.js';
+export declare class GenericNack {
+    static count: number;
+    readonly count: number;
+    header: RtcpHeader;
+    senderSsrc: number;
+    mediaSourceSsrc: number;
+    lost: number[];
+    toJSON(): {
+        lost: number[];
+        senderSsrc: number;
+        mediaSourceSsrc: number;
+    };
+    constructor(props?: Partial<GenericNack>);
+    static deSerialize(data: Buffer, header: RtcpHeader): GenericNack;
+    serialize(): Buffer<ArrayBuffer>;
+}

package/dist/types/lib/rtp/rtcp/rtpfb/twcc.d.ts

@@ -0,0 +1,71 @@
+import { RtcpHeader } from '../header.js';
+export declare class TransportWideCC {
+    static count: number;
+    count: number;
+    length: number;
+    senderSsrc: number;
+    mediaSourceSsrc: number;
+    baseSequenceNumber: number;
+    packetStatusCount: number;
+    /** 24bit multiples of 64ms */
+    referenceTime: number;
+    fbPktCount: number;
+    packetChunks: (RunLengthChunk | StatusVectorChunk)[];
+    recvDeltas: RecvDelta[];
+    header: RtcpHeader;
+    constructor(props?: Partial<TransportWideCC>);
+    static deSerialize(data: Buffer, header: RtcpHeader): TransportWideCC;
+    serialize(): Buffer<ArrayBuffer>;
+    /**
+     * The packets reported, in the order of their sequence numbers: whether each was received, and when (in
+     * milliseconds, on the clock of the receiver)
+     */
+    get packetResults(): PacketResult[];
+}
+export declare class RunLengthChunk {
+    type: PacketChunk.TypeTCCRunLengthChunk;
+    packetStatus: PacketStatus;
+    /** 13bit */
+    runLength: number;
+    constructor(props?: Partial<RunLengthChunk>);
+    static deSerialize(data: Buffer): RunLengthChunk;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare class StatusVectorChunk {
+    type: number;
+    symbolSize: number;
+    symbolList: number[];
+    constructor(props?: Partial<StatusVectorChunk>);
+    static deSerialize(data: Buffer): StatusVectorChunk;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare class RecvDelta {
+    /**optional (If undefined, it will be set automatically.)*/
+    type?: PacketStatus.TypeTCCPacketReceivedSmallDelta | PacketStatus.TypeTCCPacketReceivedLargeDelta;
+    /**micro sec */
+    delta: number;
+    constructor(props?: Partial<RecvDelta>);
+    static deSerialize(data: Buffer): RecvDelta;
+    deSerialize(data: Buffer): void;
+    parsed: boolean;
+    parseDelta(): void;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare enum PacketChunk {
+    TypeTCCRunLengthChunk = 0,
+    TypeTCCStatusVectorChunk = 1,
+    packetStatusChunkLength = 2
+}
+export declare enum PacketStatus {
+    TypeTCCPacketNotReceived = 0,
+    TypeTCCPacketReceivedSmallDelta = 1,
+    TypeTCCPacketReceivedLargeDelta = 2,
+    TypeTCCPacketReceivedWithoutDelta = 3
+}
+export declare class PacketResult {
+    sequenceNumber: number;
+    delta: number;
+    received: boolean;
+    receivedAtMs: number;
+    constructor(props: Partial<PacketResult>);
+}

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

@@ -0,0 +1,26 @@
+import { RtcpHeader } from './header.js';
+export declare class RtcpSourceDescriptionPacket {
+    static readonly type = 202;
+    readonly type = 202;
+    chunks: SourceDescriptionChunk[];
+    constructor(props: Partial<RtcpSourceDescriptionPacket>);
+    get length(): number;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(payload: Buffer, _header: RtcpHeader): RtcpSourceDescriptionPacket;
+}
+export declare class SourceDescriptionChunk {
+    source: number;
+    items: SourceDescriptionItem[];
+    constructor(props?: Partial<SourceDescriptionChunk>);
+    get length(): number;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): SourceDescriptionChunk;
+}
+export declare class SourceDescriptionItem {
+    type: number;
+    text: string;
+    constructor(props: Partial<SourceDescriptionItem>);
+    get length(): number;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): SourceDescriptionItem;
+}

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

@@ -0,0 +1,41 @@
+import { RtcpReceiverInfo } from './rr.js';
+export declare class RtcpSrPacket {
+    ssrc: number;
+    senderInfo: RtcpSenderInfo;
+    reports: RtcpReceiverInfo[];
+    static readonly type = 200;
+    readonly type = 200;
+    constructor(props: Pick<RtcpSrPacket, 'senderInfo'> & Partial<RtcpSrPacket>);
+    toJSON(): {
+        ssrc: number;
+        senderInfo: {
+            ntpTimestamp: number;
+            rtpTimestamp: number;
+        };
+        reports: {
+            ssrc: number;
+            fractionLost: number;
+            packetsLost: number;
+            highestSequence: number;
+            jitter: number;
+            lsr: number;
+            dlsr: number;
+        }[];
+    };
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(payload: Buffer, count: number): RtcpSrPacket;
+}
+export declare class RtcpSenderInfo {
+    ntpTimestamp: bigint;
+    rtpTimestamp: number;
+    packetCount: number;
+    octetCount: number;
+    constructor(props?: Partial<RtcpSenderInfo>);
+    toJSON(): {
+        ntpTimestamp: number;
+        rtpTimestamp: number;
+    };
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): RtcpSenderInfo;
+}
+export declare const ntpTime2Sec: (ntp: bigint) => number;