@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/lib/peer/media/codecCompatibility.d.ts

@@ -0,0 +1,23 @@
+import type { Kind } from '../types/domain.js';
+import type { RTCRtpCodecParameters } from './parameters.js';
+export declare function isCodecCompatible(source: RTCRtpCodecParameters, configured: RTCRtpCodecParameters): boolean;
+/**
+ * remote track が実際に配信する codec を返す。
+ * audio の RED は RTCRtpReceiver が primary へ展開してから track へ渡すため、
+ * RED が参照する primary codec (不明なら先頭の primary) を track の codec とする。
+ */
+export declare function deliveredTrackCodec(kind: string, codec: RTCRtpCodecParameters | undefined, negotiated: readonly RTCRtpCodecParameters[]): RTCRtpCodecParameters | undefined;
+/**
+ * RTX / RED を除く primary codec に MIME 一致が 1 つでもあるか。
+ * remote m-line を local capability で扱えるかの判定 (Issue #705) に使う。
+ */
+export declare function hasCommonPrimaryMimeType(local: readonly RTCRtpCodecParameters[], remote: readonly RTCRtpCodecParameters[]): boolean;
+export declare function intersectCodecs(configured: RTCRtpCodecParameters[], source: readonly RTCRtpCodecParameters[]): RTCRtpCodecParameters[];
+export declare function applyCodecPreferences(configured: RTCRtpCodecParameters[], preferences: readonly RTCRtpCodecParameters[] | undefined): RTCRtpCodecParameters[];
+export declare function resolveCodecs(configured: RTCRtpCodecParameters[], source: readonly RTCRtpCodecParameters[] | undefined, preferences: readonly RTCRtpCodecParameters[] | undefined): RTCRtpCodecParameters[];
+export declare function assertCodecsSupported(options: {
+    kind: Kind;
+    configured: RTCRtpCodecParameters[];
+    source: readonly RTCRtpCodecParameters[] | undefined;
+    preferences: readonly RTCRtpCodecParameters[] | undefined;
+}): RTCRtpCodecParameters[];

package/dist/types/lib/peer/media/extension/rtcpFeedback.d.ts

@@ -0,0 +1,6 @@
+import type { RTCPFB } from '../parameters.js';
+export declare const useFIR: () => RTCPFB;
+export declare const useNACK: () => RTCPFB;
+export declare const usePLI: () => RTCPFB;
+export declare const useREMB: () => RTCPFB;
+export declare const useTWCC: () => RTCPFB;

package/dist/types/lib/peer/media/extension/rtpExtension.d.ts

@@ -0,0 +1,9 @@
+import { RTCRtpHeaderExtensionParameters } from '../parameters.js';
+export declare function useSdesMid(): RTCRtpHeaderExtensionParameters;
+export declare function useSdesRTPStreamId(): RTCRtpHeaderExtensionParameters;
+export declare function useRepairedRtpStreamId(): RTCRtpHeaderExtensionParameters;
+export declare function useTransportWideCC(): RTCRtpHeaderExtensionParameters;
+export declare function useAbsSendTime(): RTCRtpHeaderExtensionParameters;
+export declare function useDependencyDescriptor(): RTCRtpHeaderExtensionParameters;
+export declare function useAudioLevelIndication(): RTCRtpHeaderExtensionParameters;
+export declare function useVideoOrientation(): RTCRtpHeaderExtensionParameters;

package/dist/types/lib/peer/media/index.d.ts

@@ -0,0 +1,12 @@
+export * from './codec.js';
+export * from './codecCompatibility.js';
+export * from './extension/rtcpFeedback.js';
+export * from './extension/rtpExtension.js';
+export * from './parameters.js';
+export * from './router.js';
+export * from './rtpReceiver.js';
+export * from './rtpSender.js';
+export * from './rtpTransceiver.js';
+export * from './stats.js';
+export * from '../transceiverManager.js';
+export * from './track.js';

package/dist/types/lib/peer/media/parameters.d.ts

@@ -0,0 +1,65 @@
+import type { MediaDirection } from './rtpTransceiver.js';
+export interface RTCRtpParameters {
+    codecs: RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    muxId?: string;
+    rtpStreamId?: string;
+    repairedRtpStreamId?: string;
+    rtcp?: RTCRtcpParameters;
+}
+export type RTCPFB = {
+    type: string;
+    parameter?: string;
+};
+export declare class RTCRtpCodecParameters {
+    /**
+   * When specifying a codec with a fixed payloadType such as PCMU,
+   * it is necessary to set the correct PayloadType in RTCRtpCodecParameters in advance.
+   */
+    payloadType: number;
+    mimeType: string;
+    clockRate: number;
+    channels?: number;
+    rtcpFeedback: RTCPFB[];
+    parameters?: string;
+    direction: MediaDirection | 'all';
+    constructor(props: Pick<RTCRtpCodecParameters, 'mimeType' | 'clockRate'> & Partial<RTCRtpCodecParameters>);
+    get name(): string;
+    get contentType(): string;
+    get str(): string;
+}
+export declare class RTCRtpHeaderExtensionParameters {
+    id: number;
+    uri: string;
+    constructor(props: Partial<RTCRtpHeaderExtensionParameters> & Pick<RTCRtpHeaderExtensionParameters, 'uri'>);
+}
+export declare class RTCRtcpParameters {
+    cname?: string;
+    mux: boolean;
+    ssrc?: number;
+    constructor(props?: Partial<RTCRtcpParameters>);
+}
+export declare class RTCRtcpFeedback {
+    type: string;
+    parameter?: string;
+    constructor(props?: Partial<RTCRtcpFeedback>);
+}
+export declare class RTCRtpRtxParameters {
+    ssrc: number;
+    constructor(props?: Partial<RTCRtpRtxParameters>);
+}
+export declare class RTCRtpCodingParameters {
+    ssrc: number;
+    payloadType: number;
+    rtx?: RTCRtpRtxParameters;
+    constructor(props: Partial<RTCRtpCodingParameters> & Pick<RTCRtpCodingParameters, 'ssrc' | 'payloadType'>);
+}
+export interface RTCRtpReceiveParameters extends RTCRtpParameters {
+    encodings: RTCRtpCodingParameters[];
+}
+export type RTCRtpSendParameters = RTCRtpParameters;
+export declare class RTCRtpSimulcastParameters {
+    rid: string;
+    direction: 'send' | 'recv';
+    constructor(props: RTCRtpSimulcastParameters);
+}

package/dist/types/lib/peer/media/receiver/nack.d.ts

@@ -0,0 +1,23 @@
+import { Event } from '../../imports/common.js';
+import { GenericNack, type RtpPacket } from '../../imports/rtp.js';
+import type { RTCRtpReceiver } from '../rtpReceiver.js';
+export declare class NackHandler {
+    private receiver;
+    private newEstSeqNum;
+    private _lost;
+    private nackLoop;
+    readonly onPacketLost: Event<[GenericNack]>;
+    mediaSourceSsrc?: number;
+    retryCount: number;
+    closed: boolean;
+    constructor(receiver: RTCRtpReceiver);
+    get lostSeqNumbers(): number[];
+    private getLost;
+    private setLost;
+    private removeLost;
+    addPacket(packet: RtpPacket): void;
+    private pruneLost;
+    close(): void;
+    private updateRetryCount;
+    private sendNack;
+}

package/dist/types/lib/peer/media/receiver/receiverTwcc.d.ts

@@ -0,0 +1,47 @@
+import type { RTCDtlsTransport } from '../../transport/dtls.js';
+/**
+ * The transport-wide congestion control feedback of a transport: the arrival times of the packets it receives with a
+ * transport-wide sequence number (the ones of all its streams), reported to the sender every FEEDBACK_INTERVAL. The
+ * packets missing are reported lost; the ones arriving after their report are left out.
+ */
+export declare class ReceiverTWCC {
+    private dtlsTransport;
+    /**The arrival times not reported yet, in microseconds, by sequence number (unwrapped)*/
+    readonly arrivals: Map<number, number>;
+    /** uint8 */
+    fbPktCount: number;
+    readonly rtcpSsrc: number;
+    private highestSequenceNumber?;
+    /**The first sequence number not reported yet (unwrapped)*/
+    private nextSequenceNumber?;
+    private mediaSourceSsrc;
+    private timer?;
+    constructor(dtlsTransport: RTCDtlsTransport);
+    /**
+     * A packet arrived
+     * @param transportSequenceNumber
+     * @param mediaSourceSsrc The synchronization source of the packet
+     * @param arrivalTime In microseconds
+     */
+    handleTWCC(transportSequenceNumber: number, mediaSourceSsrc: number, arrivalTime?: number): void;
+    /**
+     * Report no more
+     */
+    stop(): void;
+    /**
+     * Report the packets since the last report, up to the last one received
+     */
+    sendTWCC(): void;
+    /**
+     * The sequence number on more than 16 bits, the closest to the highest one received
+     * @param sequenceNumber
+     */
+    private unwrap;
+    /**
+     * The feedback of the packets from begin, up to end: it stops before a packet received too long after the one
+     * before (its delta not fitting 16 bits), or after MAX_PACKETS_PER_FEEDBACK
+     * @param begin
+     * @param end
+     */
+    private buildFeedback;
+}

package/dist/types/lib/peer/media/receiver/statistics.d.ts

@@ -0,0 +1,22 @@
+import type { RtpPacket } from '../../imports/rtp.js';
+export declare class StreamStatistics {
+    base_seq?: number;
+    max_seq?: number;
+    cycles: number;
+    packets_received: number;
+    bytesReceived: number;
+    headerBytesReceived: number;
+    lastPacketReceivedTimestamp?: number;
+    readonly clockRate: number;
+    jitter_q4: number;
+    private last_arrival?;
+    private last_timestamp?;
+    expected_prior: number;
+    received_prior: number;
+    constructor(clockRate: number);
+    add(packet: RtpPacket, now?: number): void;
+    get fraction_lost(): number;
+    get jitter(): number;
+    get packets_expected(): number;
+    get packets_lost(): number;
+}

package/dist/types/lib/peer/media/router.d.ts

@@ -0,0 +1,25 @@
+import { type RtcpPacket, type RtpPacket } from '../imports/rtp.js';
+import type { RTCRtpReceiveParameters, RTCRtpSimulcastParameters } from './parameters.js';
+import { RTCRtpReceiver } from './rtpReceiver.js';
+import type { RTCRtpSender } from './rtpSender.js';
+import type { RTCRtpTransceiver } from './rtpTransceiver.js';
+export declare class RtpRouter {
+    ssrcTable: {
+        [ssrc: number]: RTCRtpReceiver | RTCRtpSender;
+    };
+    ridTable: {
+        [rid: string]: RTCRtpReceiver | RTCRtpSender;
+    };
+    extIdUriMap: {
+        [id: number]: string;
+    };
+    constructor();
+    registerRtpSender(sender: RTCRtpSender): void;
+    private registerRtpReceiver;
+    registerRtpReceiverBySsrc(transceiver: RTCRtpTransceiver, params: RTCRtpReceiveParameters): void;
+    registerRtpReceiverByRid(transceiver: RTCRtpTransceiver, param: RTCRtpSimulcastParameters, params: RTCRtpReceiveParameters): void;
+    /**停止した transceiver の SSRC / RID 登録を解除する */
+    unregisterTransceiver(transceiver: RTCRtpTransceiver): void;
+    routeRtp: (packet: RtpPacket) => void;
+    routeRtcp: (packet: RtcpPacket) => void;
+}

package/dist/types/lib/peer/media/rtpReceiver.d.ts

@@ -0,0 +1,90 @@
+import { Event } from '../imports/common.js';
+import { type Extensions, type RtcpPacket, type RtpPacket } from '../imports/rtp.js';
+import type { PeerConfig } from '../peerConnection.js';
+import type { RTCDtlsTransport } from '../transport/dtls.js';
+import type { Kind } from '../types/domain.js';
+import type { RTCRtpReceiveParameters } from './parameters.js';
+import { type RTCStats, type RTCStatsReport } from './stats.js';
+import { MediaStreamTrack } from './track.js';
+export declare class RTCRtpReceiver {
+    readonly config: PeerConfig;
+    kind: Kind;
+    rtcpSsrc: number;
+    private readonly codecs;
+    private readonly defaultTrack;
+    private sortedCodecs?;
+    private get codecArray();
+    private readonly ssrcByRtx;
+    private readonly nack;
+    private readonly audioRedHandler;
+    readonly type = "receiver";
+    readonly uuid: string;
+    readonly tracks: MediaStreamTrack[];
+    readonly trackBySSRC: {
+        [ssrc: string]: MediaStreamTrack;
+    };
+    readonly trackByRID: {
+        [rid: string]: MediaStreamTrack;
+    };
+    /**last sender Report Timestamp
+   * compactNtp
+   */
+    readonly lastSRtimestamp: {
+        [ssrc: number]: number;
+    };
+    /**seconds */
+    readonly receiveLastSRTimestamp: {
+        [ssrc: number]: number;
+    };
+    readonly onPacketLost: Event<[import("../imports/rtp.js").GenericNack]>;
+    readonly onRtcp: Event<[RtcpPacket]>;
+    dtlsTransport: RTCDtlsTransport;
+    sdesMid?: string;
+    latestRid?: string;
+    latestRepairedRid?: string;
+    stopped: boolean;
+    remoteStreamId?: string;
+    remoteStreamIds: string[];
+    remoteTrackId?: string;
+    rtcpRunning: boolean;
+    private rtcpCancel;
+    private remoteStreams;
+    private senderReportsReceivedBySsrc;
+    private remoteTimestampsBySsrc;
+    private remotePacketCountBySsrc;
+    private remoteOctetCountBySsrc;
+    private nackCountBySsrc;
+    private pliCountBySsrc;
+    constructor(config: PeerConfig, kind: Kind, rtcpSsrc: number);
+    get transport(): RTCDtlsTransport;
+    setDtlsTransport(dtls: RTCDtlsTransport): void;
+    get track(): MediaStreamTrack;
+    get nackEnabled(): import("./parameters.js").RTCPFB | undefined;
+    get twccEnabled(): import("./parameters.js").RTCPFB | undefined;
+    get pliEnabled(): import("./parameters.js").RTCPFB | undefined;
+    prepareReceive(params: RTCRtpReceiveParameters): void;
+    /**
+   * negotiated codec と receiver の実処理状態を再同期する。
+   * codec map と RTX mapping を置換し、既存 remote track の codec
+   * metadata も新しい先頭 codec に更新する。
+   * transport-cc の有無は twccEnabled が新しい codec から判断する。
+   * setCodecPreferences() 後の createAnswer() 再解決や remote からの
+   * 再交渉では、除外された payload type の RTP を受け付けないようにする。
+   */
+    resyncCodecs(params: RTCRtpReceiveParameters): void;
+    addTrack(track: MediaStreamTrack): boolean;
+    stop(): void;
+    /**transceiver の停止確定時に remote track を ended にする */
+    endTracks(): void;
+    runRtcp(): Promise<void>;
+    private getInboundRtpStatsId;
+    private getRemoteOutboundRtpStatsId;
+    getStatsRootIds(selector?: MediaStreamTrack): string[];
+    collectStats(timestamp: number): RTCStats[];
+    getStats(): Promise<RTCStatsReport>;
+    sendRtcpPLI(mediaSsrc: number): Promise<void>;
+    handleRtcpPacket(packet: RtcpPacket): void;
+    handleRtpBySsrc: (packet: RtpPacket, extensions: Extensions) => void;
+    handleRtpByRid: (packet: RtpPacket, rid: string, extensions: Extensions) => void;
+    private handleRTP;
+}

package/dist/types/lib/peer/media/rtpSender.d.ts

@@ -0,0 +1,209 @@
+/**
+   [10 Nov 1995 11:33:25.125 UTC]       [10 Nov 1995 11:33:36.5 UTC]
+   n                 SR(n)              A=b710:8000 (46864.500 s)
+   ---------------------------------------------------------------->
+                      v                 ^
+   ntp_sec =0xb44db705 v               ^ dlsr=0x0005:4000 (    5.250s)
+   ntp_frac=0x20000000  v             ^  lsr =0xb705:2000 (46853.125s)
+     (3024992005.125 s)  v           ^
+   r                      v         ^ RR(n)
+   ---------------------------------------------------------------->
+                          |<-DLSR->|
+                           (5.250 s)
+        
+   A     0xb710:8000 (46864.500 s)
+   DLSR -0x0005:4000 (    5.250 s)
+   LSR  -0xb705:2000 (46853.125 s)
+   -------------------------------
+   delay 0x0006:2000 (    6.125 s)
+        
+Figure 2: Example for round-trip time computation
+ */
+import { Event } from '../imports/common.js';
+import { GenericNack, RedEncoder, type RtcpPacket, RtpHeader, RtpPacket } from '../imports/rtp.js';
+import type { RTCDtlsTransport } from '../transport/dtls.js';
+import type { Kind } from '../types/domain.js';
+import type { RTCRtpCodecParameters, RTCRtpSendParameters } from './parameters.js';
+import { type RTCStats, type RTCStatsReport } from './stats.js';
+import { type MediaStream, type MediaStreamTrack } from './track.js';
+export type PendingRtpOptions = {
+    /** Queue RTP until DTLS is connected and a codec is set. Default true when this object is passed. */
+    enabled?: boolean;
+    /** Max queued packets when enabled. Oldest packets are dropped. Default 256. */
+    maxLength?: number;
+};
+export type RTCRtpSenderOptions = {
+    /** Pending RTP cache. Disabled by default. Pass `true` or `{ maxLength }` to enable. */
+    pendingRtp?: boolean | PendingRtpOptions;
+};
+export declare class RTCRtpSender {
+    trackOrKind: Kind | MediaStreamTrack;
+    readonly type = "sender";
+    readonly kind: Kind;
+    readonly ssrc: number;
+    readonly rtxSsrc: number;
+    trackId: string;
+    readonly onReady: Event<any[]>;
+    readonly onRtcp: Event<[RtcpPacket]>;
+    readonly onPictureLossIndication: Event<[]>;
+    readonly onGenericNack: Event<[GenericNack]>;
+    readonly onStreamsChanged: Event<[]>;
+    private cname?;
+    private mid?;
+    private rtpStreamId?;
+    private repairedRtpStreamId?;
+    private rtxPayloadType?;
+    private rtxSequenceNumber;
+    redRedundantPayloadType?: number;
+    private _redDistance;
+    redEncoder: RedEncoder;
+    private headerExtensions;
+    private disposeTrack?;
+    private sendEncodings;
+    private lastSRtimestamp?;
+    private lastSentSRTimestamp?;
+    private sentAtEpochMs?;
+    private rtpTimestamp;
+    private octetCount;
+    private packetCount;
+    private headerBytesSent;
+    private rtt?;
+    private totalRoundTripTime;
+    private roundTripTimeMeasurements;
+    private retransmittedPacketsSent;
+    private retransmittedBytesSent;
+    private nackCount;
+    private pliCount;
+    private firCount;
+    private remotePacketsLost?;
+    private remoteFractionLost?;
+    receiverEstimatedMaxBitrate: bigint;
+    private sequenceNumber?;
+    private timestamp?;
+    private timestampOffset;
+    private seqOffset;
+    private rtpContinuityPending;
+    private pendingTimestampStep;
+    private rtpCache;
+    private pendingRtp;
+    private drainingPendingRtp;
+    private readonly pendingRtpEnabled;
+    private readonly pendingRtpMaxLength;
+    codec?: RTCRtpCodecParameters;
+    private negotiatedCodecs;
+    private sendPrimaryCodec?;
+    dtlsTransport: RTCDtlsTransport;
+    private dtlsDisposer;
+    track: MediaStreamTrack | null;
+    streamIds: string[];
+    stopped: boolean;
+    rtcpRunning: boolean;
+    private rtcpCancel;
+    constructor(trackOrKind: Kind | MediaStreamTrack, options?: RTCRtpSenderOptions);
+    get transport(): RTCDtlsTransport;
+    get streamId(): string | undefined;
+    set streamId(value: string | undefined);
+    setDtlsTransport(dtlsTransport: RTCDtlsTransport): void;
+    get redDistance(): number;
+    set redDistance(n: number);
+    prepareSend(params: RTCRtpSendParameters): void;
+    /**
+     * The codec sending: the first negotiated one, or the first one compatible with the codecs of the source of the
+     * track (the other side accepts any of the negotiated ones), with its retransmissions and its redundancy
+     * @param sourceCodecs
+     */
+    private selectCodec;
+    private canSendRtp;
+    private settlePendingRtp;
+    private discardPendingRtp;
+    private enqueuePendingRtp;
+    /**
+   * Send queued RTP once DTLS is connected and a codec is set. Used only when
+   * pending RTP is enabled: `writeRtp` / `sendRtp` may run before ICE/DTLS
+   * completes; dropping those packets would lose the start of a media source.
+   * `drainingPendingRtp` blocks re-entry while `dispatchRtp` is awaited;
+   * packets enqueued during that wait are drained by the recursive call after
+   * the flag is cleared.
+   */
+    private drainPendingRtp;
+    registerTrack(track: MediaStreamTrack): void;
+    /**
+     * A packet received on a connection, to send on this one: its header extensions are the ones of that connection,
+     * by their ids there. The ones about the media (the audio level, the video orientation) go on with their ids here,
+     * if negotiated; the ones of the transport are this connection's own.
+     * @param rtp
+     * @param extensions The extensions of the packet, by URI
+     */
+    private relayedRtp;
+    setStreams(streams?: MediaStream[]): void;
+    setSendEncodings(encodings?: Array<Record<string, unknown>>): void;
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+    /**
+   * Detach the current track without stopping the sender (`removeTrack`).
+   * The same sender can resume sending after `replaceTrack(track)`.
+   */
+    detachTrack(): void;
+    stop({ keepTrack }?: {
+        keepTrack?: boolean;
+    }): void;
+    runRtcp(): Promise<void>;
+    /**
+   * Send an RTP packet. Pending RTP is disabled by default: the packet is
+   * written immediately if DTLS is connected and a codec is set, otherwise
+   * dropped.
+   *
+   * When pending RTP is enabled, the packet is queued until it can be sent.
+   * The returned promise then settles for this packet only:
+   * - resolve: DTLS send completed, or the packet was dropped by `stop()`,
+   *   `replaceTrack(null)`, or pending-queue overflow
+   * - reject: DTLS send threw while writing this packet
+   *
+   * Later `sendRtp()` calls stay pending until their own packet is sent or
+   * dropped, even if a drain is already in progress.
+   * @param rtp
+   * @param owned The packet is a copy of the sender's own (a packet relayed), changed in place instead of copied again
+   */
+    sendRtp(rtp: Buffer | RtpPacket, owned?: boolean): Promise<void>;
+    /**
+   * Schedule RTP continuity rewrite for the next packet that is actually sent.
+   * The header argument is kept for API compatibility and is not used to compute
+   * offsets. `discontinuity` does not change sequence or timestamp mapping.
+   * `timestampStep` (default 1) is the only way to choose the timestamp increment
+   * at the source-switch boundary.
+   */
+    replaceRTP(header: Pick<RtpHeader, 'sequenceNumber' | 'timestamp'>, discontinuity?: boolean, timestampStep?: number): void;
+    private scheduleRtpContinuity;
+    private dispatchRtp;
+    /**
+     * The next transport-wide sequence number, shared by the senders of the transport
+     */
+    private nextTransportSequenceNumber;
+    /**
+     * A packet sent with a transport-wide sequence number, for the bandwidth estimation of the transport
+     * @param wideSeq
+     * @param size
+     * @param sendingAtMs
+     */
+    private packetSent;
+    /**
+     * Send a packet again, for a negative acknowledgement: with a new transport-wide sequence number and send time, in
+     * a retransmission packet when RTX is negotiated
+     * @param cached
+     */
+    private resendRtp;
+    handleRtcpPacket(rtcpPacket: RtcpPacket): void;
+    getParameters(): {
+        encodings: {
+            [x: string]: unknown;
+        }[];
+    };
+    setParameters(params: {
+        encodings?: Array<Record<string, unknown>>;
+    }): void;
+    private get outboundRtpStatsId();
+    private get mediaSourceStatsId();
+    private get remoteInboundRtpStatsId();
+    getStatsRootIds(): string[];
+    collectStats(timestamp: number): RTCStats[];
+    getStats(): Promise<RTCStatsReport>;
+}

package/dist/types/lib/peer/media/rtpTransceiver.d.ts

@@ -0,0 +1,117 @@
+import { Event } from '../imports/common.js';
+import type { RTCDtlsTransport } from '../index.js';
+import type { Kind } from '../types/domain.js';
+import type { RTCRtpCodecParameters, RTCRtpHeaderExtensionParameters } from './parameters.js';
+import type { RTCRtpReceiver } from './rtpReceiver.js';
+import type { RTCRtpSender } from './rtpSender.js';
+import { type RTCStats } from './stats.js';
+import type { MediaStream, MediaStreamTrack } from './track.js';
+export declare class RTCRtpTransceiver {
+    readonly kind: Kind;
+    receiver: RTCRtpReceiver;
+    sender: RTCRtpSender;
+    /**RFC 8829 4.2.4.  direction the transceiver was initialized with */
+    private _direction;
+    readonly id: string;
+    readonly onTrack: Event<[MediaStreamTrack, RTCRtpTransceiver]>;
+    mid: string | null;
+    mLineIndex?: number;
+    /**should not be reused because it has been used for sending before. */
+    usedForSender: boolean;
+    private _currentDirection?;
+    offerDirection: MediaDirection;
+    _codecs: RTCRtpCodecParameters[];
+    set codecs(codecs: RTCRtpCodecParameters[]);
+    get codecs(): RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    private _codecPreferences?;
+    readonly onCodecPreferencesChanged: Event<[]>;
+    pendingLocalOfferCodecs?: RTCRtpCodecParameters[];
+    codecPreferencesNeedResolution: boolean;
+    get codecPreferences(): readonly RTCRtpCodecParameters[] | undefined;
+    setCodecPreferences(codecs: RTCRtpCodecParameters[]): void;
+    options: Partial<TransceiverOptions>;
+    /**stop() 済み、または停止が確定した transceiver */
+    stopping: boolean;
+    /**port 0 の交渉が確定し、m-line が停止した transceiver */
+    stopped: boolean;
+    /**
+   * 共通 codec がない / remote port 0 のため answer で拒否することが確定した。
+   * `inactive` や app の `stop()` とは区別し、確定後は `stopped` も true になる。
+   */
+    rejected: boolean;
+    /**
+   * remote offer の m-line を拒否予定 (answer 未確定)。
+   * 確定するまで既存の RTP pipeline / track は維持し、rollback で false に戻す。
+   */
+    pendingRejection: boolean;
+    /**@private remote から受信中として track event を通知済みか */
+    firedReceiving: boolean;
+    /**@private Created by addTrack: a media of a remote offer not associated yet may take it (RFC 8829 5.10)*/
+    addedByAddTrack: boolean;
+    /**@private app の stop() 要求を manager に伝える */
+    readonly onStopRequested: Event<[]>;
+    /**@private 停止の確定または stop() でメディア資源を解放する際に通知する */
+    readonly onRelease: Event<[]>;
+    /**@private The direction set by the application changed: it is negotiated (W3C: the negotiation-needed flag)*/
+    readonly onDirectionChanged: Event<[]>;
+    constructor(kind: Kind, dtlsTransport: RTCDtlsTransport | undefined, receiver: RTCRtpReceiver, sender: RTCRtpSender, 
+    /**RFC 8829 4.2.4.  direction the transceiver was initialized with */
+    _direction: MediaDirection);
+    get dtlsTransport(): RTCDtlsTransport;
+    /**RFC 8829 4.2.4. setDirectionに渡された最後の値を示します */
+    get direction(): MediaDirection;
+    set direction(direction: MediaDirection);
+    setDirection(direction: MediaDirection): void;
+    /**RFC 8829 4.2.5. last negotiated direction */
+    get currentDirection(): CurrentDirection | null;
+    setCurrentDirection(direction: CurrentDirection | undefined): void;
+    setDtlsTransport(dtls: RTCDtlsTransport): void;
+    get msid(): string;
+    get msids(): string[];
+    addTrack(track: MediaStreamTrack): void;
+    /**m-line (MID / index) と関連付け済みか */
+    get associated(): boolean;
+    /**
+   * https://www.w3.org/TR/webrtc/#dom-rtcrtptransceiver-stop
+   * 送受信をただちに止めて資源を解放し、次の自分の offer で port 0 を交渉する。
+   * 冪等で、2 回目以降は何もしない。
+   */
+    stop(): void;
+    /**
+   * @private
+   * port 0 の交渉確定 (自分の stop の answer / remote による拒否) を反映する。
+   */
+    commitStopped({ rejected }: {
+        rejected: boolean;
+    }): void;
+    private markStopped;
+    private releaseMedia;
+    forceStop(): void;
+    getPayloadType(mimeType: string): number | undefined;
+    getCodecStats(): RTCStats[];
+    collectCodecStats(timestamp: number): RTCStats[];
+}
+export declare const Inactive = "inactive";
+export declare const Sendonly = "sendonly";
+export declare const Recvonly = "recvonly";
+export declare const Sendrecv = "sendrecv";
+export declare const Directions: readonly ["inactive", "sendonly", "recvonly", "sendrecv"];
+export type MediaDirection = (typeof Directions)[number];
+export type CurrentDirection = MediaDirection | 'stopped';
+type SimulcastDirection = 'send' | 'recv';
+export interface RTCRtpEncodingParameters {
+    active?: boolean;
+    rid?: string;
+    maxBitrate?: number;
+}
+export interface TransceiverOptions {
+    direction: MediaDirection;
+    sendEncodings: RTCRtpEncodingParameters[];
+    simulcast: {
+        direction: SimulcastDirection;
+        rid: string;
+    }[];
+    streams: MediaStream[];
+}
+export {};

package/dist/types/lib/peer/media/sender/cumulativeResult.d.ts

@@ -0,0 +1,19 @@
+export declare class CumulativeResult {
+    numPackets: number;
+    /**byte */
+    totalSize: number;
+    firstPacketSentAtMs: number;
+    lastPacketSentAtMs: number;
+    firstPacketReceivedAtMs: number;
+    lastPacketReceivedAtMs: number;
+    /**
+   *
+   * @param size byte
+   * @param sentAtMs
+   * @param receivedAtMs
+   */
+    addPacket(size: number, sentAtMs: number, receivedAtMs: number): void;
+    reset(): void;
+    get receiveBitrate(): number;
+    get sendBitrate(): number;
+}