@observertc/observer-js 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/index.d.ts

@@ -0,0 +1,2952 @@
+import { EventEmitter } from 'events';
+import { types } from 'mediasoup';
+
+/**
+* The WebRTC app provided custom stats payload
+*/
+type ExtensionStat = {
+    /**
+    * The type of the extension stats the custom app provides
+    */
+    type: string;
+    /**
+    * The payload of the extension stats the custom app provides
+    */
+    payload?: string;
+};
+/**
+* A list of additional client events.
+*/
+type ClientMetaData = {
+    /**
+    * The name of the event used as an identifier (e.g., MEDIA_TRACK_MUTED, USER_REJOINED, etc.).
+    */
+    type: string;
+    /**
+    * The value associated with the event, if applicable.
+    */
+    payload?: string;
+    /**
+    * The unique identifier of the peer connection for which the event was generated.
+    */
+    peerConnectionId?: string;
+    /**
+    * The identifier of the media track related to the event, if applicable.
+    */
+    trackId?: string;
+    /**
+    * The SSRC (Synchronization Source) identifier associated with the event, if applicable.
+    */
+    ssrc?: number;
+    /**
+    * The timestamp in epoch format when the event was generated.
+    */
+    timestamp?: number;
+};
+/**
+* A list of client issues.
+*/
+type ClientIssue = {
+    /**
+    * The name of the issue
+    */
+    type: string;
+    /**
+    * The value associated with the event, if applicable.
+    */
+    payload?: string;
+    /**
+    * The timestamp in epoch format when the event was generated.
+    */
+    timestamp?: number;
+};
+/**
+* A list of client events.
+*/
+type ClientEvent = {
+    /**
+    * The name of the event used as an identifier (e.g., MEDIA_TRACK_MUTED, USER_REJOINED, etc.).
+    */
+    type: string;
+    /**
+    * The value associated with the event, if applicable.
+    */
+    payload?: string;
+    /**
+    * The timestamp in epoch format when the event was generated.
+    */
+    timestamp?: number;
+};
+/**
+* Certificates
+*/
+type CertificateStats = {
+    /**
+    * The timestamp of the stat.
+    */
+    timestamp: number;
+    /**
+    * A unique identifier for the stat.
+    */
+    id: string;
+    /**
+    * The fingerprint of the certificate.
+    */
+    fingerprint?: string;
+    /**
+    * The algorithm used for the fingerprint (e.g., 'SHA-256').
+    */
+    fingerprintAlgorithm?: string;
+    /**
+    * The certificate encoded in base64 format.
+    */
+    base64Certificate?: string;
+    /**
+    * The certificate ID of the issuer (nullable).
+    */
+    issuerCertificateId?: string;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* ICE Candidate Pair Stats
+*/
+type IceCandidatePairStats = {
+    /**
+    * The unique identifier for this RTCStats object.
+    */
+    id: string;
+    /**
+    * The timestamp of when the stats were recorded, in seconds.
+    */
+    timestamp: number;
+    /**
+    * The transport id of the connection this candidate pair belongs to.
+    */
+    transportId?: string;
+    /**
+    * The ID of the local ICE candidate in this pair.
+    */
+    localCandidateId?: string;
+    /**
+    * The ID of the remote ICE candidate in this pair.
+    */
+    remoteCandidateId?: string;
+    state?: 'new' | 'in-progress' | 'waiting' | 'failed' | 'succeeded' | 'cancelled' | 'inprogress';
+    /**
+    * Whether this candidate pair has been nominated.
+    */
+    nominated?: boolean;
+    /**
+    * The number of packets sent using this candidate pair.
+    */
+    packetsSent?: number;
+    /**
+    * The number of packets received using this candidate pair.
+    */
+    packetsReceived?: number;
+    /**
+    * The total number of bytes sent using this candidate pair.
+    */
+    bytesSent?: number;
+    /**
+    * The total number of bytes received using this candidate pair.
+    */
+    bytesReceived?: number;
+    /**
+    * The timestamp of the last packet sent using this candidate pair.
+    */
+    lastPacketSentTimestamp?: number;
+    /**
+    * The timestamp of the last packet received using this candidate pair.
+    */
+    lastPacketReceivedTimestamp?: number;
+    /**
+    * The total round trip time (RTT) for this candidate pair in seconds.
+    */
+    totalRoundTripTime?: number;
+    /**
+    * The current round trip time (RTT) for this candidate pair in seconds.
+    */
+    currentRoundTripTime?: number;
+    /**
+    * The available outgoing bitrate (in bits per second) for this candidate pair.
+    */
+    availableOutgoingBitrate?: number;
+    /**
+    * The available incoming bitrate (in bits per second) for this candidate pair.
+    */
+    availableIncomingBitrate?: number;
+    /**
+    * The number of ICE connection requests received by this candidate pair.
+    */
+    requestsReceived?: number;
+    /**
+    * The number of ICE connection requests sent by this candidate pair.
+    */
+    requestsSent?: number;
+    /**
+    * The number of ICE connection responses received by this candidate pair.
+    */
+    responsesReceived?: number;
+    /**
+    * The number of ICE connection responses sent by this candidate pair.
+    */
+    responsesSent?: number;
+    /**
+    * The number of ICE connection consent requests sent by this candidate pair.
+    */
+    consentRequestsSent?: number;
+    /**
+    * The number of packets discarded while attempting to send via this candidate pair.
+    */
+    packetsDiscardedOnSend?: number;
+    /**
+    * The total number of bytes discarded while attempting to send via this candidate pair.
+    */
+    bytesDiscardedOnSend?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* ICE Candidate Stats
+*/
+type IceCandidateStats = {
+    /**
+    * The timestamp of the stat.
+    */
+    timestamp: number;
+    /**
+    * A unique identifier for the stat.
+    */
+    id: string;
+    /**
+    * The transport ID associated with the ICE candidate.
+    */
+    transportId?: string;
+    /**
+    * The IP address of the ICE candidate (nullable).
+    */
+    address?: string;
+    /**
+    * The port number of the ICE candidate.
+    */
+    port?: number;
+    /**
+    * The transport protocol used by the candidate (e.g., 'udp', 'tcp').
+    */
+    protocol?: string;
+    /**
+    * The type of the ICE candidate (e.g., 'host', 'srflx', 'relay').
+    */
+    candidateType?: string;
+    /**
+    * The priority of the ICE candidate.
+    */
+    priority?: number;
+    /**
+    * The URL of the ICE candidate.
+    */
+    url?: string;
+    /**
+    * The protocol used for the relay (e.g., 'tcp', 'udp').
+    */
+    relayProtocol?: string;
+    /**
+    * A string representing the foundation for the ICE candidate.
+    */
+    foundation?: string;
+    /**
+    * The related address for the ICE candidate (if any).
+    */
+    relatedAddress?: string;
+    /**
+    * The related port for the ICE candidate (if any).
+    */
+    relatedPort?: number;
+    /**
+    * The username fragment for the ICE candidate.
+    */
+    usernameFragment?: string;
+    /**
+    * The TCP type of the ICE candidate (e.g., 'active', 'passive').
+    */
+    tcpType?: string;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* ICE Transport Stats
+*/
+type IceTransportStats = {
+    /**
+    * The timestamp of the stat.
+    */
+    timestamp: number;
+    /**
+    * A unique identifier for the stat.
+    */
+    id: string;
+    /**
+    * The number of packets sent.
+    */
+    packetsSent?: number;
+    /**
+    * The number of packets received.
+    */
+    packetsReceived?: number;
+    /**
+    * The number of bytes sent.
+    */
+    bytesSent?: number;
+    /**
+    * The number of bytes received.
+    */
+    bytesReceived?: number;
+    /**
+    * The ICE role (e.g., 'controlling', 'controlled').
+    */
+    iceRole?: string;
+    /**
+    * The local username fragment for ICE.
+    */
+    iceLocalUsernameFragment?: string;
+    /**
+    * The DTLS transport state (e.g., 'new', 'connecting', 'connected').
+    */
+    dtlsState?: string;
+    /**
+    * The ICE transport state (e.g., 'new', 'checking', 'connected').
+    */
+    iceState?: string;
+    /**
+    * The ID of the selected ICE candidate pair.
+    */
+    selectedCandidatePairId?: string;
+    /**
+    * The ID of the local certificate.
+    */
+    localCertificateId?: string;
+    /**
+    * The ID of the remote certificate.
+    */
+    remoteCertificateId?: string;
+    /**
+    * The TLS version used for encryption.
+    */
+    tlsVersion?: string;
+    /**
+    * The DTLS cipher suite used.
+    */
+    dtlsCipher?: string;
+    /**
+    * The role in the DTLS handshake (e.g., 'client', 'server').
+    */
+    dtlsRole?: string;
+    /**
+    * The SRTP cipher used for encryption.
+    */
+    srtpCipher?: string;
+    /**
+    * The number of changes to the selected ICE candidate pair.
+    */
+    selectedCandidatePairChanges?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Data Channels Stats
+*/
+type DataChannelStats = {
+    /**
+    * The timestamp of the stat.
+    */
+    timestamp: number;
+    /**
+    * A unique identifier for the stat.
+    */
+    id: string;
+    /**
+    * The label of the data channel.
+    */
+    label?: string;
+    /**
+    * The protocol of the data channel.
+    */
+    protocol?: string;
+    /**
+    * The identifier for the data channel.
+    */
+    dataChannelIdentifier?: number;
+    /**
+    * The state of the data channel (e.g., 'open', 'closed').
+    */
+    state?: string;
+    /**
+    * The number of messages sent on the data channel.
+    */
+    messagesSent?: number;
+    /**
+    * The number of bytes sent on the data channel.
+    */
+    bytesSent?: number;
+    /**
+    * The number of messages received on the data channel.
+    */
+    messagesReceived?: number;
+    /**
+    * The number of bytes received on the data channel.
+    */
+    bytesReceived?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* PeerConnection Transport Stats
+*/
+type PeerConnectionTransportStats = {
+    /**
+    * The timestamp of the stat.
+    */
+    timestamp: number;
+    /**
+    * A unique identifier for the stat.
+    */
+    id: string;
+    /**
+    * The number of data channels opened.
+    */
+    dataChannelsOpened?: number;
+    /**
+    * The number of data channels closed.
+    */
+    dataChannelsClosed?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Media Playout Stats
+*/
+type MediaPlayoutStats = {
+    /**
+    * The timestamp of the stat.
+    */
+    timestamp: number;
+    /**
+    * A unique identifier for the stat.
+    */
+    id: string;
+    /**
+    * The kind of media (audio/video).
+    */
+    kind: string;
+    /**
+    * The duration of synthesized audio samples.
+    */
+    synthesizedSamplesDuration?: number;
+    /**
+    * The number of synthesized audio samples events.
+    */
+    synthesizedSamplesEvents?: number;
+    /**
+    * The total duration of all audio samples.
+    */
+    totalSamplesDuration?: number;
+    /**
+    * The total delay experienced during audio playout.
+    */
+    totalPlayoutDelay?: number;
+    /**
+    * The total count of audio samples.
+    */
+    totalSamplesCount?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Audio Source Stats
+*/
+type MediaSourceStats = {
+    /**
+    * The timestamp of the stat.
+    */
+    timestamp: number;
+    /**
+    * A unique identifier for the stat.
+    */
+    id: string;
+    /**
+    * The type of media ('audio' or 'video').
+    */
+    kind: string;
+    /**
+    * The identifier of the media track.
+    */
+    trackIdentifier?: string;
+    /**
+    * The current audio level.
+    */
+    audioLevel?: number;
+    /**
+    * The total audio energy.
+    */
+    totalAudioEnergy?: number;
+    /**
+    * The total duration of audio samples.
+    */
+    totalSamplesDuration?: number;
+    /**
+    * The echo return loss.
+    */
+    echoReturnLoss?: number;
+    /**
+    * The enhancement of echo return loss.
+    */
+    echoReturnLossEnhancement?: number;
+    /**
+    * The width of the video.
+    */
+    width?: number;
+    /**
+    * The height of the video.
+    */
+    height?: number;
+    /**
+    * The total number of frames.
+    */
+    frames?: number;
+    /**
+    * The frames per second of the video.
+    */
+    framesPerSecond?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Remote Outbound RTPs
+*/
+type RemoteOutboundRtpStats = {
+    /**
+    * The timestamp for this stats object in DOMHighResTimeStamp format.
+    */
+    timestamp: number;
+    /**
+    * The unique identifier for this stats object.
+    */
+    id: string;
+    /**
+    * The SSRC identifier of the RTP stream.
+    */
+    ssrc: number;
+    /**
+    * The type of media ('audio' or 'video').
+    */
+    kind: string;
+    /**
+    * The ID of the transport used for this stream.
+    */
+    transportId?: string;
+    /**
+    * The ID of the codec used for this stream.
+    */
+    codecId?: string;
+    /**
+    * The total number of packets sent on this stream.
+    */
+    packetsSent?: number;
+    /**
+    * The total number of bytes sent on this stream.
+    */
+    bytesSent?: number;
+    /**
+    * The ID of the local object corresponding to this stream.
+    */
+    localId?: string;
+    /**
+    * The remote timestamp for this stats object in DOMHighResTimeStamp format.
+    */
+    remoteTimestamp?: number;
+    /**
+    * The total number of reports sent on this stream.
+    */
+    reportsSent?: number;
+    /**
+    * The current estimated round-trip time for this stream in seconds.
+    */
+    roundTripTime?: number;
+    /**
+    * The total round-trip time for this stream in seconds.
+    */
+    totalRoundTripTime?: number;
+    /**
+    * The total number of round-trip time measurements for this stream.
+    */
+    roundTripTimeMeasurements?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* The duration of quality limitation reasons categorized by type.
+*/
+type QualityLimitationDurations = {
+    /**
+    * Duration of no quality limitation in seconds.
+    */
+    none: number;
+    /**
+    * Duration of CPU-based quality limitation in seconds.
+    */
+    cpu: number;
+    /**
+    * Duration of bandwidth-based quality limitation in seconds.
+    */
+    bandwidth: number;
+    /**
+    * Duration of other quality limitation reasons in seconds.
+    */
+    other: number;
+};
+/**
+* Outbound RTPs
+*/
+type OutboundRtpStats = {
+    /**
+    * The timestamp for this stats object in DOMHighResTimeStamp format.
+    */
+    timestamp: number;
+    /**
+    * The unique identifier for this stats object.
+    */
+    id: string;
+    /**
+    * The SSRC identifier of the RTP stream.
+    */
+    ssrc: number;
+    /**
+    * The type of media ('audio' or 'video').
+    */
+    kind: string;
+    /**
+    * The ID of the transport used for this stream.
+    */
+    transportId?: string;
+    /**
+    * The ID of the codec used for this stream.
+    */
+    codecId?: string;
+    /**
+    * The total number of packets sent on this stream.
+    */
+    packetsSent?: number;
+    /**
+    * The total number of bytes sent on this stream.
+    */
+    bytesSent?: number;
+    /**
+    * The media ID associated with this RTP stream.
+    */
+    mid?: string;
+    /**
+    * The ID of the media source associated with this stream.
+    */
+    mediaSourceId?: string;
+    /**
+    * The ID of the remote object corresponding to this stream.
+    */
+    remoteId?: string;
+    /**
+    * The RID value of the RTP stream.
+    */
+    rid?: string;
+    /**
+    * The total number of header bytes sent on this stream.
+    */
+    headerBytesSent?: number;
+    /**
+    * The number of retransmitted packets sent on this stream.
+    */
+    retransmittedPacketsSent?: number;
+    /**
+    * The number of retransmitted bytes sent on this stream.
+    */
+    retransmittedBytesSent?: number;
+    /**
+    * The SSRC for the RTX stream, if applicable.
+    */
+    rtxSsrc?: number;
+    /**
+    * The target bitrate for this RTP stream in bits per second.
+    */
+    targetBitrate?: number;
+    /**
+    * The total target encoded bytes for this stream.
+    */
+    totalEncodedBytesTarget?: number;
+    /**
+    * The width of the frames sent in pixels.
+    */
+    frameWidth?: number;
+    /**
+    * The height of the frames sent in pixels.
+    */
+    frameHeight?: number;
+    /**
+    * The number of frames sent per second.
+    */
+    framesPerSecond?: number;
+    /**
+    * The total number of frames sent on this stream.
+    */
+    framesSent?: number;
+    /**
+    * The total number of huge frames sent on this stream.
+    */
+    hugeFramesSent?: number;
+    /**
+    * The total number of frames encoded on this stream.
+    */
+    framesEncoded?: number;
+    /**
+    * The total number of key frames encoded on this stream.
+    */
+    keyFramesEncoded?: number;
+    /**
+    * The sum of QP values for all frames encoded on this stream.
+    */
+    qpSum?: number;
+    /**
+    * The total time spent encoding frames on this stream in seconds.
+    */
+    totalEncodeTime?: number;
+    /**
+    * The total delay for packets sent on this stream in seconds.
+    */
+    totalPacketSendDelay?: number;
+    /**
+    * The reason for any quality limitation on this stream.
+    */
+    qualityLimitationReason?: string;
+    /**
+    * The number of resolution changes due to quality limitations.
+    */
+    qualityLimitationResolutionChanges?: number;
+    /**
+    * The total number of NACK packets sent on this stream.
+    */
+    nackCount?: number;
+    /**
+    * The total number of FIR packets sent on this stream.
+    */
+    firCount?: number;
+    /**
+    * The total number of PLI packets sent on this stream.
+    */
+    pliCount?: number;
+    /**
+    * The implementation of the encoder used for this stream.
+    */
+    encoderImplementation?: string;
+    /**
+    * Indicates whether the encoder is power efficient.
+    */
+    powerEfficientEncoder?: boolean;
+    /**
+    * Indicates whether this stream is actively sending data.
+    */
+    active?: boolean;
+    /**
+    * The scalability mode of the encoder used for this stream.
+    */
+    scalabilityMode?: string;
+    /**
+    * The duration of quality limitation reasons categorized by type.
+    */
+    qualityLimitationDurations?: QualityLimitationDurations;
+    /**
+    * Additional information attached to this stats.
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Remote Inbound RTPs
+*/
+type RemoteInboundRtpStats = {
+    /**
+    * The timestamp for this stats object in DOMHighResTimeStamp format.
+    */
+    timestamp: number;
+    /**
+    * The unique identifier for this stats object.
+    */
+    id: string;
+    /**
+    * The SSRC identifier of the RTP stream.
+    */
+    ssrc: number;
+    /**
+    * The type of media ('audio' or 'video').
+    */
+    kind: string;
+    /**
+    * The ID of the transport used for this stream.
+    */
+    transportId?: string;
+    /**
+    * The ID of the codec used for this stream.
+    */
+    codecId?: string;
+    /**
+    * The total number of packets received on this stream.
+    */
+    packetsReceived?: number;
+    /**
+    * The total number of packets lost on this stream.
+    */
+    packetsLost?: number;
+    /**
+    * The jitter value for this stream in seconds.
+    */
+    jitter?: number;
+    /**
+    * The ID of the local object corresponding to this remote stream.
+    */
+    localId?: string;
+    /**
+    * The most recent RTT measurement for this stream in seconds.
+    */
+    roundTripTime?: number;
+    /**
+    * The cumulative RTT for all packets on this stream in seconds.
+    */
+    totalRoundTripTime?: number;
+    /**
+    * The fraction of packets lost on this stream, calculated over a time interval.
+    */
+    fractionLost?: number;
+    /**
+    * The total number of RTT measurements for this stream.
+    */
+    roundTripTimeMeasurements?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Inbound RTPs
+*/
+type InboundRtpStats = {
+    /**
+    * The time the stats were collected, in high-resolution time.
+    */
+    timestamp: number;
+    /**
+    * Unique identifier of the stats object.
+    */
+    id: string;
+    /**
+    * Synchronization source identifier of the RTP stream.
+    */
+    ssrc: number;
+    /**
+    * Kind of the media (e.g., 'audio' or 'video').
+    */
+    kind: string;
+    /**
+    * Identifier for the media track associated with the RTP stream.
+    */
+    trackIdentifier: string;
+    /**
+    * ID of the transport associated with the RTP stream.
+    */
+    transportId?: string;
+    /**
+    * ID of the codec used for the RTP stream.
+    */
+    codecId?: string;
+    /**
+    * Number of packets received on the RTP stream.
+    */
+    packetsReceived?: number;
+    /**
+    * Number of packets lost on the RTP stream.
+    */
+    packetsLost?: number;
+    /**
+    * Jitter of the RTP stream in seconds.
+    */
+    jitter?: number;
+    /**
+    * The MediaStream ID of the RTP stream.
+    */
+    mid?: string;
+    /**
+    * Remote stats object ID associated with the RTP stream.
+    */
+    remoteId?: string;
+    /**
+    * Number of frames decoded.
+    */
+    framesDecoded?: number;
+    /**
+    * Number of keyframes decoded.
+    */
+    keyFramesDecoded?: number;
+    /**
+    * Number of frames rendered.
+    */
+    framesRendered?: number;
+    /**
+    * Number of frames dropped.
+    */
+    framesDropped?: number;
+    /**
+    * Width of the decoded video frames.
+    */
+    frameWidth?: number;
+    /**
+    * Height of the decoded video frames.
+    */
+    frameHeight?: number;
+    /**
+    * Frame rate in frames per second.
+    */
+    framesPerSecond?: number;
+    /**
+    * Sum of the Quantization Parameter values for decoded frames.
+    */
+    qpSum?: number;
+    /**
+    * Total time spent decoding in seconds.
+    */
+    totalDecodeTime?: number;
+    /**
+    * Sum of inter-frame delays in seconds.
+    */
+    totalInterFrameDelay?: number;
+    /**
+    * Sum of squared inter-frame delays in seconds.
+    */
+    totalSquaredInterFrameDelay?: number;
+    /**
+    * Number of times playback was paused.
+    */
+    pauseCount?: number;
+    /**
+    * Total duration of pauses in seconds.
+    */
+    totalPausesDuration?: number;
+    /**
+    * Number of times playback was frozen.
+    */
+    freezeCount?: number;
+    /**
+    * Total duration of freezes in seconds.
+    */
+    totalFreezesDuration?: number;
+    /**
+    * Timestamp of the last packet received.
+    */
+    lastPacketReceivedTimestamp?: number;
+    /**
+    * Total header bytes received.
+    */
+    headerBytesReceived?: number;
+    /**
+    * Total packets discarded.
+    */
+    packetsDiscarded?: number;
+    /**
+    * Total bytes received from FEC.
+    */
+    fecBytesReceived?: number;
+    /**
+    * Total packets received from FEC.
+    */
+    fecPacketsReceived?: number;
+    /**
+    * Total FEC packets discarded.
+    */
+    fecPacketsDiscarded?: number;
+    /**
+    * Total bytes received on the RTP stream.
+    */
+    bytesReceived?: number;
+    /**
+    * Number of NACKs sent.
+    */
+    nackCount?: number;
+    /**
+    * Number of Full Intra Requests sent.
+    */
+    firCount?: number;
+    /**
+    * Number of Picture Loss Indications sent.
+    */
+    pliCount?: number;
+    /**
+    * Total processing delay in seconds.
+    */
+    totalProcessingDelay?: number;
+    /**
+    * Estimated timestamp of playout.
+    */
+    estimatedPlayoutTimestamp?: number;
+    /**
+    * Total jitter buffer delay in seconds.
+    */
+    jitterBufferDelay?: number;
+    /**
+    * Target delay for the jitter buffer in seconds.
+    */
+    jitterBufferTargetDelay?: number;
+    /**
+    * Number of packets emitted from the jitter buffer.
+    */
+    jitterBufferEmittedCount?: number;
+    /**
+    * Minimum delay of the jitter buffer in seconds.
+    */
+    jitterBufferMinimumDelay?: number;
+    /**
+    * Total audio samples received.
+    */
+    totalSamplesReceived?: number;
+    /**
+    * Number of concealed audio samples.
+    */
+    concealedSamples?: number;
+    /**
+    * Number of silent audio samples concealed.
+    */
+    silentConcealedSamples?: number;
+    /**
+    * Number of audio concealment events.
+    */
+    concealmentEvents?: number;
+    /**
+    * Number of audio samples inserted for deceleration.
+    */
+    insertedSamplesForDeceleration?: number;
+    /**
+    * Number of audio samples removed for acceleration.
+    */
+    removedSamplesForAcceleration?: number;
+    /**
+    * Audio level in the range [0.0, 1.0].
+    */
+    audioLevel?: number;
+    /**
+    * Total audio energy in the stream.
+    */
+    totalAudioEnergy?: number;
+    /**
+    * Total duration of all received audio samples in seconds.
+    */
+    totalSamplesDuration?: number;
+    /**
+    * Total number of frames received.
+    */
+    framesReceived?: number;
+    /**
+    * Decoder implementation used for decoding frames.
+    */
+    decoderImplementation?: string;
+    /**
+    * Playout identifier for the RTP stream.
+    */
+    playoutId?: string;
+    /**
+    * Indicates if the decoder is power-efficient.
+    */
+    powerEfficientDecoder?: boolean;
+    /**
+    * Number of frames assembled from multiple packets.
+    */
+    framesAssembledFromMultiplePackets?: number;
+    /**
+    * Total assembly time for frames in seconds.
+    */
+    totalAssemblyTime?: number;
+    /**
+    * Number of retransmitted packets received.
+    */
+    retransmittedPacketsReceived?: number;
+    /**
+    * Number of retransmitted bytes received.
+    */
+    retransmittedBytesReceived?: number;
+    /**
+    * SSRC of the retransmission stream.
+    */
+    rtxSsrc?: number;
+    /**
+    * SSRC of the FEC stream.
+    */
+    fecSsrc?: number;
+    /**
+    * Total corruption probability of packets.
+    */
+    totalCorruptionProbability?: number;
+    /**
+    * Total squared corruption probability of packets.
+    */
+    totalSquaredCorruptionProbability?: number;
+    /**
+    * Number of corruption measurements.
+    */
+    corruptionMeasurements?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Codec items
+*/
+type CodecStats = {
+    /**
+    * The timestamp when the stats were generated.
+    */
+    timestamp: number;
+    /**
+    * The unique identifier for the stats object.
+    */
+    id: string;
+    /**
+    * The MIME type of the codec.
+    */
+    mimeType: string;
+    /**
+    * The payload type of the codec.
+    */
+    payloadType?: number;
+    /**
+    * The identifier of the transport associated with the codec.
+    */
+    transportId?: string;
+    /**
+    * The clock rate of the codec in Hz.
+    */
+    clockRate?: number;
+    /**
+    * The number of audio channels for the codec, if applicable.
+    */
+    channels?: number;
+    /**
+    * The SDP format-specific parameters line for the codec.
+    */
+    sdpFmtpLine?: string;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Outbound Track Stats items
+*/
+type OutboundTrackSample = {
+    /**
+    * The timestamp when the stats were generated.
+    */
+    timestamp: number;
+    /**
+    * The unique identifier for the stats object.
+    */
+    id: string;
+    /**
+    * Kind of the media (e.g., 'audio' or 'video').
+    */
+    kind: string;
+    /**
+    * Calculated score for track (details should be added to attachments)
+    */
+    score?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* Inbound Track Stats items
+*/
+type InboundTrackSample = {
+    /**
+    * The timestamp when the stats were generated.
+    */
+    timestamp: number;
+    /**
+    * The unique identifier for the stats object.
+    */
+    id: string;
+    /**
+    * Kind of the media (e.g., 'audio' or 'video').
+    */
+    kind: string;
+    /**
+    * Calculated score for track (details should be added to attachments)
+    */
+    score?: number;
+    /**
+    * Additional information attached to this stats
+    */
+    attachments?: Record<string, unknown>;
+};
+/**
+* docs
+*/
+type PeerConnectionSample = {
+    /**
+    * Unique identifier of the stats object.
+    */
+    peerConnectionId: string;
+    /**
+    * Additional information attached to this sample
+    */
+    attachments?: Record<string, unknown>;
+    /**
+    * Calculated score for peer connection (details should be added to attachments)
+    */
+    score?: number;
+    /**
+    * Inbound Track Stats items
+    */
+    inboundTracks?: InboundTrackSample[];
+    /**
+    * Outbound Track Stats items
+    */
+    outboundTracks?: OutboundTrackSample[];
+    /**
+    * Codec items
+    */
+    codecs?: CodecStats[];
+    /**
+    * Inbound RTPs
+    */
+    inboundRtps?: InboundRtpStats[];
+    /**
+    * Remote Inbound RTPs
+    */
+    remoteInboundRtps?: RemoteInboundRtpStats[];
+    /**
+    * Outbound RTPs
+    */
+    outboundRtps?: OutboundRtpStats[];
+    /**
+    * Remote Outbound RTPs
+    */
+    remoteOutboundRtps?: RemoteOutboundRtpStats[];
+    /**
+    * Audio Source Stats
+    */
+    mediaSources?: MediaSourceStats[];
+    /**
+    * Media Playout Stats
+    */
+    mediaPlayouts?: MediaPlayoutStats[];
+    /**
+    * PeerConnection Transport Stats
+    */
+    peerConnectionTransports?: PeerConnectionTransportStats[];
+    /**
+    * Data Channels Stats
+    */
+    dataChannels?: DataChannelStats[];
+    /**
+    * ICE Transport Stats
+    */
+    iceTransports?: IceTransportStats[];
+    /**
+    * ICE Candidate Stats
+    */
+    iceCandidates?: IceCandidateStats[];
+    /**
+    * ICE Candidate Pair Stats
+    */
+    iceCandidatePairs?: IceCandidatePairStats[];
+    /**
+    * Certificates
+    */
+    certificates?: CertificateStats[];
+};
+/**
+* docs
+*/
+type ClientSample = {
+    /**
+    * The timestamp the sample is created in GMT
+    */
+    timestamp: number;
+    /**
+    * the unique identifier of the call or session
+    */
+    callId?: string;
+    /**
+    * Unique id of the client providing samples.
+    */
+    clientId?: string;
+    /**
+    * Additional information attached to this sample (e.g.: roomId, userId, displayName, etc...)
+    */
+    attachments?: Record<string, unknown>;
+    /**
+    * Calculated score for client (details should be added to attachments)
+    */
+    score?: number;
+    /**
+    * Samples taken PeerConnections
+    */
+    peerConnections?: PeerConnectionSample[];
+    /**
+    * A list of client events.
+    */
+    clientEvents?: ClientEvent[];
+    /**
+    * A list of client issues.
+    */
+    clientIssues?: ClientIssue[];
+    /**
+    * A list of additional client events.
+    */
+    clientMetaItems?: ClientMetaData[];
+    /**
+    * The WebRTC app provided custom stats payload
+    */
+    extensionStats?: ExtensionStat[];
+};
+
+type CalculatedScore = {
+    weight: number;
+    value?: number;
+    appData?: Record<string, unknown>;
+};
+
+type MediaKind = 'audio' | 'video';
+
+declare class ObservedMediaPlayout implements MediaPlayoutStats {
+    timestamp: number;
+    id: string;
+    kind: MediaKind;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    synthesizedSamplesDuration?: number | undefined;
+    synthesizedSamplesEvents?: number | undefined;
+    totalSamplesDuration?: number | undefined;
+    totalPlayoutDelay?: number | undefined;
+    totalSamplesCount?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    update(stats: MediaPlayoutStats): void;
+}
+
+declare class ObservedMediaSource implements MediaSourceStats {
+    timestamp: number;
+    id: string;
+    kind: MediaKind;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    trackIdentifier?: string | undefined;
+    audioLevel?: number | undefined;
+    totalAudioEnergy?: number | undefined;
+    totalSamplesDuration?: number | undefined;
+    echoReturnLoss?: number | undefined;
+    echoReturnLossEnhancement?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    frames?: number | undefined;
+    framesPerSecond?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getTrack(): ObservedOutboundTrack | undefined;
+    update(stats: MediaSourceStats): void;
+}
+
+declare class ObservedIceCandidate implements IceCandidateStats {
+    timestamp: number;
+    id: string;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    transportId?: string | undefined;
+    address?: string | undefined;
+    port?: number | undefined;
+    protocol?: string | undefined;
+    candidateType?: string | undefined;
+    priority?: number | undefined;
+    url?: string | undefined;
+    relayProtocol?: string | undefined;
+    foundation?: string | undefined;
+    relatedAddress?: string | undefined;
+    relatedPort?: number | undefined;
+    usernameFragment?: string | undefined;
+    tcpType?: string | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getIceTransport(): ObservedIceTransport | undefined;
+    update(stats: IceCandidateStats): void;
+}
+
+declare class ObservedIceCandidatePair implements IceCandidatePairStats {
+    timestamp: number;
+    id: string;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    transportId?: string | undefined;
+    localCandidateId?: string | undefined;
+    remoteCandidateId?: string | undefined;
+    state?: 'new' | 'in-progress' | 'waiting' | 'failed' | 'succeeded' | undefined;
+    nominated?: boolean | undefined;
+    packetsSent?: number | undefined;
+    packetsReceived?: number | undefined;
+    bytesSent?: number | undefined;
+    bytesReceived?: number | undefined;
+    lastPacketSentTimestamp?: number | undefined;
+    lastPacketReceivedTimestamp?: number | undefined;
+    totalRoundTripTime?: number | undefined;
+    currentRoundTripTime?: number | undefined;
+    availableOutgoingBitrate?: number | undefined;
+    availableIncomingBitrate?: number | undefined;
+    requestsReceived?: number | undefined;
+    requestsSent?: number | undefined;
+    responsesReceived?: number | undefined;
+    responsesSent?: number | undefined;
+    consentRequestsSent?: number | undefined;
+    packetsDiscardedOnSend?: number | undefined;
+    bytesDiscardedOnSend?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    deltaBytesSent: number;
+    deltaBytesReceived: number;
+    deltaPacketsSent: number;
+    deltaPacketsReceived: number;
+    constructor(timestamp: number, id: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getIceTransport(): ObservedIceTransport | undefined;
+    getLocalCandidate(): ObservedIceCandidate | undefined;
+    getRemoteCandidate(): ObservedIceCandidate | undefined;
+    update(stats: IceCandidatePairStats): void;
+    private _convertState;
+}
+
+declare class ObservedIceTransport implements IceTransportStats {
+    timestamp: number;
+    id: string;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    packetsSent?: number | undefined;
+    packetsReceived?: number | undefined;
+    bytesSent?: number | undefined;
+    bytesReceived?: number | undefined;
+    iceRole?: string | undefined;
+    iceLocalUsernameFragment?: string | undefined;
+    dtlsState?: string | undefined;
+    iceState?: string | undefined;
+    selectedCandidatePairId?: string | undefined;
+    localCertificateId?: string | undefined;
+    remoteCertificateId?: string | undefined;
+    tlsVersion?: string | undefined;
+    dtlsCipher?: string | undefined;
+    dtlsRole?: string | undefined;
+    srtpCipher?: string | undefined;
+    selectedCandidatePairChanges?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    deltaPacketsReceived: number;
+    deltaPacketsSent: number;
+    deltaBytesReceived: number;
+    deltaBytesSent: number;
+    constructor(timestamp: number, id: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getSelectedCandidatePair(): ObservedIceCandidatePair | undefined;
+    update(stats: IceTransportStats): void;
+}
+
+declare class ObservedCodec implements CodecStats {
+    timestamp: number;
+    id: string;
+    mimeType: string;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    payloadType?: number | undefined;
+    transportId?: string | undefined;
+    clockRate?: number | undefined;
+    channels?: number | undefined;
+    sdpFmtpLine?: string | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, mimeType: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getIceTransport(): ObservedIceTransport | undefined;
+    update(stats: CodecStats): void;
+}
+
+declare class ObservedRemoteInboundRtp implements RemoteInboundRtpStats {
+    timestamp: number;
+    id: string;
+    ssrc: number;
+    kind: MediaKind;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    transportId?: string | undefined;
+    codecId?: string | undefined;
+    packetsReceived?: number | undefined;
+    packetsLost?: number | undefined;
+    jitter?: number | undefined;
+    localId?: string | undefined;
+    roundTripTime?: number | undefined;
+    totalRoundTripTime?: number | undefined;
+    fractionLost?: number | undefined;
+    roundTripTimeMeasurements?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, ssrc: number, kind: MediaKind, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getOutboundRtp(): ObservedOutboundRtp | undefined;
+    getCodec(): ObservedCodec | undefined;
+    update(stats: RemoteInboundRtpStats): void;
+}
+
+declare class ObservedOutboundRtp implements OutboundRtpStats {
+    timestamp: number;
+    id: string;
+    ssrc: number;
+    kind: MediaKind;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    transportId?: string | undefined;
+    codecId?: string | undefined;
+    packetsSent?: number | undefined;
+    bytesSent?: number | undefined;
+    mid?: string | undefined;
+    mediaSourceId?: string | undefined;
+    remoteId?: string | undefined;
+    rid?: string | undefined;
+    headerBytesSent?: number | undefined;
+    retransmittedPacketsSent?: number | undefined;
+    retransmittedBytesSent?: number | undefined;
+    rtxSsrc?: number | undefined;
+    targetBitrate?: number | undefined;
+    totalEncodedBytesTarget?: number | undefined;
+    frameWidth?: number | undefined;
+    frameHeight?: number | undefined;
+    framesPerSecond?: number | undefined;
+    framesSent?: number | undefined;
+    hugeFramesSent?: number | undefined;
+    framesEncoded?: number | undefined;
+    keyFramesEncoded?: number | undefined;
+    qpSum?: number | undefined;
+    totalEncodeTime?: number | undefined;
+    totalPacketSendDelay?: number | undefined;
+    qualityLimitationReason?: string | undefined;
+    qualityLimitationResolutionChanges?: number | undefined;
+    nackCount?: number | undefined;
+    firCount?: number | undefined;
+    pliCount?: number | undefined;
+    encoderImplementation?: string | undefined;
+    powerEfficientEncoder?: boolean | undefined;
+    active?: boolean | undefined;
+    scalabilityMode?: string | undefined;
+    qualityLimitationDurations?: QualityLimitationDurations | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    bitrate: number;
+    payloadBitrate: number;
+    packetRate: number;
+    bitPerPixel: number;
+    deltaPacketsSent: number;
+    deltaBytesSent: number;
+    remoteRttInMs?: number;
+    remoteFractionLost?: number;
+    remoteJitter?: number;
+    remotePacketsLost?: number;
+    constructor(timestamp: number, id: string, ssrc: number, kind: MediaKind, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getRemoteInboundRtp(): ObservedRemoteInboundRtp | undefined;
+    getCodec(): ObservedCodec | undefined;
+    getMediaSource(): ObservedMediaSource | undefined;
+    getTrack(): ObservedOutboundTrack | undefined;
+    update(stats: OutboundRtpStats): void;
+}
+
+declare class ObservedOutboundTrack implements OutboundTrackSample {
+    timestamp: number;
+    readonly id: string;
+    readonly kind: MediaKind;
+    private readonly _peerConnection;
+    private readonly _outboundRtps?;
+    private readonly _mediaSource?;
+    private _visited;
+    appData?: Record<string, unknown>;
+    readonly remoteInboundTracks: Set<ObservedInboundTrack>;
+    readonly calculatedScore: CalculatedScore;
+    addedAt?: number | undefined;
+    removedAt?: number | undefined;
+    muted?: boolean;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection, _outboundRtps?: ObservedOutboundRtp[] | undefined, _mediaSource?: ObservedMediaSource | undefined);
+    get score(): number | undefined;
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getOutboundRtps(): ObservedOutboundRtp[] | undefined;
+    getMediaSource(): ObservedMediaSource | undefined;
+    update(stats: OutboundTrackSample): void;
+}
+
+declare class ObservedInboundTrack implements InboundTrackSample {
+    timestamp: number;
+    readonly id: string;
+    readonly kind: MediaKind;
+    private readonly _peerConnection;
+    private readonly _inboundRtp?;
+    private readonly _mediaPlayout?;
+    readonly calculatedScore: CalculatedScore;
+    appData?: Record<string, unknown>;
+    remoteOutboundTrack?: ObservedOutboundTrack | undefined;
+    private _visited;
+    addedAt?: number | undefined;
+    removedAt?: number | undefined;
+    muted?: boolean;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection, _inboundRtp?: ObservedInboundRtp | undefined, _mediaPlayout?: ObservedMediaPlayout | undefined);
+    get score(): number | undefined;
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getInboundRtp(): ObservedInboundRtp | undefined;
+    getMediaPlayout(): ObservedMediaPlayout | undefined;
+    update(stats: InboundTrackSample): void;
+}
+
+declare class ObservedRemoteOutboundRtp implements RemoteOutboundRtpStats {
+    timestamp: number;
+    id: string;
+    ssrc: number;
+    kind: MediaKind;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    transportId?: string | undefined;
+    codecId?: string | undefined;
+    packetsSent?: number | undefined;
+    bytesSent?: number | undefined;
+    localId?: string | undefined;
+    remoteTimestamp?: number | undefined;
+    reportsSent?: number | undefined;
+    roundTripTime?: number | undefined;
+    totalRoundTripTime?: number | undefined;
+    roundTripTimeMeasurements?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, ssrc: number, kind: MediaKind, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getInboundRtp(): ObservedInboundRtp | undefined;
+    getCodec(): ObservedCodec | undefined;
+    update(stats: RemoteOutboundRtpStats): void;
+}
+
+declare class ObservedInboundRtp implements InboundRtpStats {
+    timestamp: number;
+    id: string;
+    ssrc: number;
+    kind: MediaKind;
+    trackIdentifier: string;
+    private readonly _peerConnection;
+    appData?: Record<string, unknown>;
+    private _visited;
+    transportId?: string | undefined;
+    codecId?: string | undefined;
+    packetsReceived?: number | undefined;
+    packetsLost?: number | undefined;
+    mid?: string | undefined;
+    remoteId?: string | undefined;
+    framesDecoded?: number | undefined;
+    keyFramesDecoded?: number | undefined;
+    framesRendered?: number | undefined;
+    framesDropped?: number | undefined;
+    frameWidth?: number | undefined;
+    frameHeight?: number | undefined;
+    framesPerSecond?: number | undefined;
+    qpSum?: number | undefined;
+    totalDecodeTime?: number | undefined;
+    totalInterFrameDelay?: number | undefined;
+    totalSquaredInterFrameDelay?: number | undefined;
+    pauseCount?: number | undefined;
+    totalPausesDuration?: number | undefined;
+    freezeCount?: number | undefined;
+    totalFreezesDuration?: number | undefined;
+    lastPacketReceivedTimestamp?: number | undefined;
+    headerBytesReceived?: number | undefined;
+    packetsDiscarded?: number | undefined;
+    fecBytesReceived?: number | undefined;
+    fecPacketsReceived?: number | undefined;
+    fecPacketsDiscarded?: number | undefined;
+    bytesReceived?: number | undefined;
+    nackCount?: number | undefined;
+    firCount?: number | undefined;
+    pliCount?: number | undefined;
+    totalProcessingDelay?: number | undefined;
+    estimatedPlayoutTimestamp?: number | undefined;
+    jitterBufferDelay?: number | undefined;
+    jitterBufferTargetDelay?: number | undefined;
+    jitterBufferEmittedCount?: number | undefined;
+    jitterBufferMinimumDelay?: number | undefined;
+    totalSamplesReceived?: number | undefined;
+    concealedSamples?: number | undefined;
+    silentConcealedSamples?: number | undefined;
+    concealmentEvents?: number | undefined;
+    insertedSamplesForDeceleration?: number | undefined;
+    removedSamplesForAcceleration?: number | undefined;
+    audioLevel?: number | undefined;
+    totalAudioEnergy?: number | undefined;
+    totalSamplesDuration?: number | undefined;
+    framesReceived?: number | undefined;
+    decoderImplementation?: string | undefined;
+    playoutId?: string | undefined;
+    powerEfficientDecoder?: boolean | undefined;
+    framesAssembledFromMultiplePackets?: number | undefined;
+    totalAssemblyTime?: number | undefined;
+    retransmittedPacketsReceived?: number | undefined;
+    retransmittedBytesReceived?: number | undefined;
+    rtxSsrc?: number | undefined;
+    fecSsrc?: number | undefined;
+    totalCorruptionProbability?: number | undefined;
+    totalSquaredCorruptionProbability?: number | undefined;
+    corruptionMeasurements?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    jitter?: number | undefined;
+    bitrate: number;
+    fractionLost?: number;
+    bitPerPixel: number;
+    deltaLostPackets: number;
+    deltaReceivedPackets: number;
+    deltaBytesReceived: number;
+    deltaReceivedSamples: number;
+    deltaSilentConcealedSamples: number;
+    remoteRttInMs?: number;
+    remoteBytesSent?: number;
+    remotePacketsSent?: number;
+    remoteTimestamp?: number;
+    constructor(timestamp: number, id: string, ssrc: number, kind: MediaKind, trackIdentifier: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    getRemoteOutboundRtp(): ObservedRemoteOutboundRtp | undefined;
+    getIceTransport(): ObservedIceTransport | undefined;
+    getCodec(): ObservedCodec | undefined;
+    getMediaPlayout(): ObservedMediaPlayout | undefined;
+    getTrack(): ObservedInboundTrack | undefined;
+    update(stats: InboundRtpStats): void;
+}
+
+declare class ObservedCertificate implements CertificateStats {
+    timestamp: number;
+    id: string;
+    private readonly _peerConnection;
+    appData?: Record<string, unknown>;
+    private _visited;
+    fingerprint?: string;
+    fingerprintAlgorithm?: string;
+    base64Certificate?: string;
+    issuerCertificateId?: string;
+    attachments?: Record<string, unknown>;
+    constructor(timestamp: number, id: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    update(stats: CertificateStats): void;
+}
+
+declare class ObservedDataChannel implements DataChannelStats {
+    timestamp: number;
+    id: string;
+    private readonly _peerConnection;
+    private _visited;
+    label?: string | undefined;
+    protocol?: string | undefined;
+    dataChannelIdentifier?: number | undefined;
+    state?: string | undefined;
+    messagesSent?: number | undefined;
+    bytesSent?: number | undefined;
+    messagesReceived?: number | undefined;
+    bytesReceived?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    addedAt?: number | undefined;
+    removedAt?: number | undefined;
+    deltaBytesSent: number;
+    deltaBytesReceived: number;
+    deltaMessagesSent: number;
+    deltaMessagesReceived: number;
+    appData?: Record<string, unknown>;
+    constructor(timestamp: number, id: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    update(stats: DataChannelStats): void;
+}
+
+declare class ObservedPeerConnectionTransport implements PeerConnectionTransportStats {
+    timestamp: number;
+    id: string;
+    private readonly _peerConnection;
+    private _visited;
+    appData?: Record<string, unknown>;
+    dataChannelsOpened?: number | undefined;
+    dataChannelsClosed?: number | undefined;
+    attachments?: Record<string, unknown> | undefined;
+    constructor(timestamp: number, id: string, _peerConnection: ObservedPeerConnection);
+    get visited(): boolean;
+    getPeerConnection(): ObservedPeerConnection;
+    update(stats: PeerConnectionTransportStats): void;
+}
+
+type ObservedTURNEventMap = {
+    'update': [ObservedTURN];
+    'close': [];
+};
+declare interface ObservedTURN {
+    on<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+    off<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+    once<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+    emit<U extends keyof ObservedTURNEventMap>(event: U, ...args: ObservedTURNEventMap[U]): boolean;
+}
+declare class ObservedTURN extends EventEmitter {
+    totalBytesSent: number;
+    totalBytesReceived: number;
+    totalPacketsSent: number;
+    totalPacketsReceived: number;
+    packetsSentPerSecond: number;
+    packetsReceivedPerSecond: number;
+    outboundBitrate: number;
+    inboundBitrate: number;
+    numberOfClients: number;
+    readonly servers: Map<string, ObservedTurnServer>;
+    constructor();
+    update(): void;
+    addPeerConnection(peerConnection: ObservedPeerConnection): ObservedTurnServer | undefined;
+    removePeerConnection(peerConnection: ObservedPeerConnection): void;
+}
+
+declare class ObservedTurnServer {
+    readonly url: string;
+    readonly observedTURN: ObservedTURN;
+    totalBytesSent: number;
+    totalBytesReceived: number;
+    totalPacketsSent: number;
+    totalPacketsReceived: number;
+    packetsSentPerSecond: number;
+    packetsReceivedPerSecond: number;
+    outboundBitrate: number;
+    inboundBitrate: number;
+    deltaBytesSent: number;
+    deltaBytesReceived: number;
+    deltaPacketsSent: number;
+    deltaPacketsReceived: number;
+    readonly observedPeerConnections: Map<string, ObservedPeerConnection>;
+    updated: number;
+    constructor(url: string, observedTURN: ObservedTURN);
+    updateTurnUsage(...selectedcandidatepairs: ObservedIceCandidatePair[]): void;
+    update(): void;
+}
+
+type ObservedPeerConnectionEvents = {
+    'removed-inbound-track': [ObservedInboundTrack];
+    'removed-outbound-track': [ObservedOutboundTrack];
+    close: [];
+};
+declare interface ObservedPeerConnection {
+    on<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
+    off<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
+    once<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
+    emit<U extends keyof ObservedPeerConnectionEvents>(event: U, ...args: ObservedPeerConnectionEvents[U]): boolean;
+}
+declare class ObservedPeerConnection extends EventEmitter {
+    readonly peerConnectionId: string;
+    readonly client: ObservedClient;
+    private _visited;
+    appData?: Record<string, unknown>;
+    readonly calculatedScore: CalculatedScore;
+    closed: boolean;
+    openedAt?: number;
+    closedAt?: number;
+    updated: number;
+    connectionState?: 'new' | 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed';
+    iceConnectionState?: 'new' | 'checking' | 'connected' | 'completed' | 'failed' | 'disconnected' | 'closed';
+    iceGatheringState?: 'new' | 'gathering' | 'complete';
+    availableIncomingBitrate: number;
+    availableOutgoingBitrate: number;
+    totalInboundPacketsLost: number;
+    totalInboundPacketsReceived: number;
+    totalOutboundPacketsSent: number;
+    totalDataChannelBytesSent: number;
+    totalDataChannelBytesReceived: number;
+    totalDataChannelMessagesSent: number;
+    totalDataChannelMessagesReceived: number;
+    totalSentAudioBytes: number;
+    totalSentVideoBytes: number;
+    totalSentAudioPackets: number;
+    totalSentVideoPackets: number;
+    totalReceivedAudioPacktes: number;
+    totalReceivedVideoPackets: number;
+    totalReceivedAudioBytes: number;
+    totalReceivedVideoBytes: number;
+    deltaInboundPacketsLost: number;
+    deltaInboundPacketsReceived: number;
+    deltaOutboundPacketsSent: number;
+    deltaDataChannelBytesSent: number;
+    deltaDataChannelBytesReceived: number;
+    deltaDataChannelMessagesSent: number;
+    deltaDataChannelMessagesReceived: number;
+    deltaInboundReceivedBytes: number;
+    deltaOutboundSentBytes: number;
+    deltaReceivedAudioBytes: number;
+    deltaReceivedVideoBytes: number;
+    deltaReceivedAudioPackets: number;
+    deltaReceivedVideoPackets: number;
+    deltaSentAudioBytes: number;
+    deltaSentVideoBytes: number;
+    deltaSentAudioPackets: number;
+    deltaSentVideoPackets: number;
+    deltaTransportSentBytes: number;
+    deltaTransportReceivedBytes: number;
+    receivingPacketsPerSecond: number;
+    sendingPacketsPerSecond: number;
+    sendingAudioBitrate: number;
+    sendingVideoBitrate: number;
+    receivingAudioBitrate: number;
+    receivingVideoBitrate: number;
+    currentRttInMs?: number;
+    currentJitter?: number;
+    usingTCP: boolean;
+    usingTURN: boolean;
+    observedTurnServer?: ObservedTurnServer;
+    readonly observedCertificates: Map<string, ObservedCertificate>;
+    readonly observedCodecs: Map<string, ObservedCodec>;
+    readonly observedDataChannels: Map<string, ObservedDataChannel>;
+    readonly observedIceCandidates: Map<string, ObservedIceCandidate>;
+    readonly observedIceCandidatesPair: Map<string, ObservedIceCandidatePair>;
+    readonly observedIceTransports: Map<string, ObservedIceTransport>;
+    readonly observedInboundRtps: Map<number, ObservedInboundRtp>;
+    readonly observedInboundTracks: Map<string, ObservedInboundTrack>;
+    readonly observedMediaPlayouts: Map<string, ObservedMediaPlayout>;
+    readonly observedMediaSources: Map<string, ObservedMediaSource>;
+    readonly observedOutboundRtps: Map<number, ObservedOutboundRtp>;
+    readonly observedOutboundTracks: Map<string, ObservedOutboundTrack>;
+    readonly observedPeerConnectionTransports: Map<string, ObservedPeerConnectionTransport>;
+    readonly observedRemoteInboundRtps: Map<number, ObservedRemoteInboundRtp>;
+    readonly observedRemoteOutboundRtps: Map<number, ObservedRemoteOutboundRtp>;
+    private readonly eventScope;
+    constructor(peerConnectionId: string, client: ObservedClient);
+    get score(): number | undefined;
+    get visited(): boolean;
+    get codecs(): ObservedCodec[];
+    get inboundRtps(): ObservedInboundRtp[];
+    get remoteOutboundRtps(): ObservedRemoteOutboundRtp[];
+    get outboundRtps(): ObservedOutboundRtp[];
+    get remoteInboundRtps(): ObservedRemoteInboundRtp[];
+    get mediaSources(): ObservedMediaSource[];
+    get mediaPlayouts(): ObservedMediaPlayout[];
+    get dataChannels(): ObservedDataChannel[];
+    get peerConnectionTransports(): ObservedPeerConnectionTransport[];
+    get iceTransports(): ObservedIceTransport[];
+    get iceCandidates(): ObservedIceCandidate[];
+    get iceCandidatePairs(): ObservedIceCandidatePair[];
+    get certificates(): ObservedCertificate[];
+    get selectedIceCandidatePairs(): ObservedIceCandidatePair[];
+    get selectedIceCandiadtePairForTurn(): ObservedIceCandidatePair[];
+    close(): void;
+    accept(sample: PeerConnectionSample, context?: AcceptContext): void;
+    private _checkVisited;
+    private _updateCertificateStats;
+    private _updateCodecStats;
+    private _updateDataChannelStats;
+    private _updateIceCandidateStats;
+    private _updateIceCandidatePairStats;
+    private _updateIceTransportStats;
+    private _updateInboundRtpStats;
+    private _updateInboundTrackSample;
+    private _updateMediaPlayoutStats;
+    private _updateMediaSourceStats;
+    private _updateOutboundRtpStats;
+    private _updateOutboundTrackSample;
+    private _updatePeerConnectionTransportStats;
+    private _updateRemoteInboundRtpStats;
+    private _updateRemoteOutboundRtpStats;
+    /** Emit an Observer-bus event scoped to this peer connection. */
+    private _notify;
+}
+
+declare enum ClientMetaTypes {
+    MEDIA_CONSTRAINT = "MEDIA_CONSTRAINT",
+    MEDIA_DEVICE = "MEDIA_DEVICE",
+    MEDIA_DEVICES_SUPPORTED_CONSTRAINTS = "MEDIA_DEVICES_SUPPORTED_CONSTRAINTS",
+    USER_MEDIA_ERROR = "USER_MEDIA_ERROR",
+    LOCAL_SDP = "LOCAL_SDP",
+    OPERATION_SYSTEM = "OPERATION_SYSTEM",
+    ENGINE = "ENGINE",
+    PLATFORM = "PLATFORM",
+    BROWSER = "BROWSER"
+}
+type MediaDeviceInfo = {
+    deviceId: string;
+    label: string;
+    kind: string;
+    groupId: string;
+};
+type Browser = {
+    name: string;
+    version: string;
+};
+type Platform = {
+    name: string;
+    version: string;
+};
+type Engine = {
+    name: string;
+    version: string;
+};
+type OperationSystem = {
+    name: string;
+    version: string;
+};
+
+/** The lifecycle events a sink may emit (a subset of Node's writable-stream events). */
+type ClientSampleSinkEvents = {
+    /** The destination is fully written and closed (e.g. a file flushed and its fd closed). */
+    close: [];
+    /** The destination failed. */
+    error: [Error];
+    /** `end()` was processed and all queued data was flushed (before `close`). */
+    finish: [];
+    /** The buffer drained after backpressure; safe to write more. */
+    drain: [];
+};
+declare interface ClientSampleSink {
+    on<E extends keyof ClientSampleSinkEvents>(event: E, listener: (...args: ClientSampleSinkEvents[E]) => void): this;
+    once<E extends keyof ClientSampleSinkEvents>(event: E, listener: (...args: ClientSampleSinkEvents[E]) => void): this;
+    off<E extends keyof ClientSampleSinkEvents>(event: E, listener: (...args: ClientSampleSinkEvents[E]) => void): this;
+    emit<E extends keyof ClientSampleSinkEvents>(event: E, ...args: ClientSampleSinkEvents[E]): boolean;
+}
+/**
+ * A per-client destination for accepted samples — a typed `EventEmitter` base class. One sink is
+ * created per `ObservedClient` (via `ObserverConfig.createClientSink`). It is **object-mode**:
+ * `write` receives the `ClientSample` itself, so each sink decides how to serialize it (JSON
+ * line, protobuf, msgpack, a remote payload, …).
+ *
+ * The library calls `write(sample)` synchronously per accepted sample (not awaited), `end()`s the
+ * sink when the client closes, and attaches an `error` listener so a failing sink can't crash the
+ * process. The application — which created the sink — listens for `close` (destination ready,
+ * e.g. a file flushed and its fd closed) and `error`.
+ *
+ * Subclass this and implement `write`/`end` (and `emit` your lifecycle events). Built-in sinks
+ * (`JsonlFileSink`, `InMemorySink`) and their factories are exported from the package root.
+ */
+declare abstract class ClientSampleSink extends EventEmitter {
+    /** Accept one sample; the sink serializes it however it likes. `false` signals backpressure. */
+    abstract write(sample: ClientSample): boolean;
+    /** Finish writing; the sink flushes and (if applicable) emits `close`. */
+    abstract end(): void;
+}
+/**
+ * Produces a sink for a newly-created client, or `undefined` for no sink. Receives the
+ * client id and its (already-created) parent call, so the destination can be derived
+ * from `callId` / `clientId`.
+ */
+type ClientSampleSinkFactory = (params: {
+    clientId: string;
+    observedCall: ObservedCall;
+}) => ClientSampleSink | undefined;
+
+/** mediasoup `TransportTuple` (the selected local/remote address pair of a transport). */
+type TransportTuple = {
+    localAddress: string;
+    localPort: number;
+    remoteIp?: string;
+    remotePort?: number;
+    protocol: 'udp' | 'tcp';
+};
+/** mediasoup `RtpCodecParameters` (the negotiated codec of a producer/consumer). */
+type RtpCodecParameters = {
+    mimeType: string;
+    payloadType: number;
+    clockRate: number;
+    channels?: number;
+    parameters?: Record<string, unknown>;
+    rtcpFeedback?: {
+        type: string;
+        parameter?: string;
+    }[];
+};
+type SampleHistoryItem<T extends string> = Record<string, unknown> & {
+    type: T;
+    timestamp: number;
+};
+type MediasoupRouterSample = Record<string, unknown> & {
+    routerId: string;
+    attachments: Record<string, unknown>;
+    createdAt: number;
+    closedAt?: number;
+    producers: MediasoupProducerSample[];
+    consumers: MediasoupConsumerSample[];
+    dataProducers: MediasoupDataProducerSample[];
+    dataConsumers: MediasoupDataConsumerSample[];
+    transports: MediasoupTransportSample[];
+};
+type MediasoupWebRtcTransportSampleEventTypes = 'icestate-changed-to-new' | 'icestate-changed-to-connected' | 'icestate-changed-to-completed' | 'icestate-changed-to-disconnected' | 'icestate-changed-to-closed' | 'dtlsstate-changed-to-new' | 'dtlsstate-changed-to-connecting' | 'dtlsstate-changed-to-connected' | 'dtlsstate-changed-to-failed' | 'dtlsstate-changed-to-closed' | 'sctpstate-changed-to-new' | 'sctpstate-changed-to-connecting' | 'sctpstate-changed-to-connected' | 'sctpstate-changed-to-failed' | 'sctpstate-changed-to-closed' | 'iceselectedtuple-changed';
+type MediasoupWebRtcTransportSampleEventMap = {
+    [K in MediasoupWebRtcTransportSampleEventTypes]: SampleHistoryItem<K>;
+}[MediasoupWebRtcTransportSampleEventTypes];
+type MediasoupWebRtcTransportSample = {
+    type: 'webrtc';
+    history: MediasoupWebRtcTransportSampleEventMap[];
+};
+type MediasoupPlainTransportSampleEventTypes = 'sctpstate-changed-to-new' | 'sctpstate-changed-to-connecting' | 'sctpstate-changed-to-connected' | 'sctpstate-changed-to-failed' | 'sctpstate-changed-to-closed' | 'tuple-changed' | 'rtcptuple-changed';
+type MediasoupPlainTransportSampleEventMap = {
+    [K in MediasoupPlainTransportSampleEventTypes]: SampleHistoryItem<K>;
+}[MediasoupPlainTransportSampleEventTypes];
+type MediasoupPlainTransportSample = {
+    type: 'plain';
+    rtcpTuple?: TransportTuple;
+    history: MediasoupPlainTransportSampleEventMap[];
+};
+type MediasoupPipeTransportSampleEventTypes = 'sctpstate-changed-to-new' | 'sctpstate-changed-to-connecting' | 'sctpstate-changed-to-connected' | 'sctpstate-changed-to-failed' | 'sctpstate-changed-to-closed';
+type MediasoupPipeTransportSampleEventMap = {
+    [K in MediasoupPipeTransportSampleEventTypes]: SampleHistoryItem<K>;
+}[MediasoupPipeTransportSampleEventTypes];
+type MediasoupPipeTransportSample = {
+    type: 'pipe';
+    history: MediasoupPipeTransportSampleEventMap[];
+};
+type MediasoupDirectTransportSampleEventTypes = never;
+type MediasoupDirectTransportSampleEventMap = {
+    [K in MediasoupDirectTransportSampleEventTypes]: SampleHistoryItem<K>;
+}[MediasoupDirectTransportSampleEventTypes];
+type MediasoupDirectTransportSample = {
+    type: 'direct';
+    history: MediasoupDirectTransportSampleEventMap[];
+};
+type MediasoupTransportSample = Record<string, unknown> & {
+    id: string;
+    createdAt: number;
+    connectedAt?: number;
+    closedAt?: number;
+    tuple?: TransportTuple;
+} & (MediasoupWebRtcTransportSample | MediasoupPlainTransportSample | MediasoupPipeTransportSample | MediasoupDirectTransportSample);
+type MediasoupProducerSampleEventMap = {
+    'pause': undefined;
+    'resume': undefined;
+    'degraded': undefined;
+    'restored': undefined;
+};
+type MediasoupProducerSampleEvent = {
+    [K in keyof MediasoupProducerSampleEventMap]: SampleHistoryItem<K>;
+}[keyof MediasoupProducerSampleEventMap];
+type MediasoupProducerSample = Record<string, unknown> & {
+    id: string;
+    transportId: string;
+    createdAt: number;
+    closedAt?: number;
+    codecInfo: RtpCodecParameters;
+    kind: 'audio' | 'video';
+    ssrcs?: number[];
+    rids?: string[];
+    history: MediasoupProducerSampleEvent[];
+};
+type MediasoupConsumerSampleEventMap = {
+    'pause': undefined;
+    'resume': undefined;
+    'producerPaused': undefined;
+    'producerResumed': undefined;
+    'stopped': undefined;
+    'started': undefined;
+    'degraded': undefined;
+    'restored': undefined;
+};
+type MediasoupConsumerSampleEvent = {
+    [K in keyof MediasoupConsumerSampleEventMap]: SampleHistoryItem<K>;
+}[keyof MediasoupConsumerSampleEventMap];
+type MediasoupConsumerSample = Record<string, unknown> & {
+    id: string;
+    producerId: string;
+    transportId: string;
+    createdAt: number;
+    closedAt?: number;
+    kind: 'audio' | 'video';
+    history: MediasoupConsumerSampleEvent[];
+};
+type MediasoupDataProducerSample = Record<string, unknown> & {
+    id: string;
+    transportId: string;
+    createdAt: number;
+    closedAt?: number;
+    label: string;
+    protocol: string;
+};
+type MediasoupDataConsumerSample = Record<string, unknown> & {
+    id: string;
+    dataProducerId: string;
+    transportId: string;
+    createdAt: number;
+    closedAt?: number;
+    label: string;
+    protocol: string;
+};
+
+type ObservedMediasoupRouterSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
+    router: types.Router;
+    appData?: AppData;
+    attachments?: Record<string, unknown>;
+};
+type ObservedMediasoupRouterEvents = {
+    close: [];
+};
+declare interface ObservedMediasoupRouter {
+    on<U extends keyof ObservedMediasoupRouterEvents>(event: U, listener: (...args: ObservedMediasoupRouterEvents[U]) => void): this;
+    off<U extends keyof ObservedMediasoupRouterEvents>(event: U, listener: (...args: ObservedMediasoupRouterEvents[U]) => void): this;
+    once<U extends keyof ObservedMediasoupRouterEvents>(event: U, listener: (...args: ObservedMediasoupRouterEvents[U]) => void): this;
+    emit<U extends keyof ObservedMediasoupRouterEvents>(event: U, ...args: ObservedMediasoupRouterEvents[U]): boolean;
+}
+declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
+    readonly router: types.Router;
+    readonly sample: MediasoupRouterSample;
+    appData: AppData;
+    readonly webrtcTransportIds: Set<string>;
+    get attachments(): Record<string, unknown>;
+    closed: boolean;
+    constructor(settings: ObservedMediasoupRouterSettings<AppData>);
+    get id(): string;
+    addTransport: (transport: types.Transport) => void;
+    addWebRtcTransport(transport: types.WebRtcTransport): void;
+    addPlainTransport(transport: types.PlainTransport): void;
+    addPipeTransport(transport: types.PipeTransport): void;
+    addDirectTransport(transport: types.DirectTransport): void;
+    addProducer(transport: types.Transport, producer: types.Producer): void;
+    addConsumer(transport: types.Transport, consumer: types.Consumer): void;
+    addDataProducer(transport: types.Transport, dataProducer: types.DataProducer): void;
+    addDataConsumer(transport: types.Transport, dataConsumer: types.DataConsumer): void;
+    close(): void;
+    private attachRouterListeners;
+    private _attachTransportObserverListeners;
+}
+
+/**
+ * The Observer is the single event bus for the whole hierarchy. Every event
+ * worth subscribing to is emitted on the Observer with a payload object that
+ * carries the ancestry of the entity it originates from, down to the subject,
+ * plus the optional `context` passed through `accept(sample, context?)`.
+ *
+ * Lifecycle/coordination events (close, update, joined, left, newclient, ...)
+ * remain as local EventEmitter events on each Observed* component so that
+ * parent/child teardown and the updaters can wire to them directly.
+ */
+/** Base fields present on every Observer event payload. */
+type ObserverEventBase = {
+    observer: Observer;
+    context?: AcceptContext;
+};
+/** Scope reaching a call. */
+type ObservedCallScope = ObserverEventBase & {
+    observedCall: ObservedCall;
+};
+/** Scope reaching a client (carries its call). */
+type ObservedClientScope = ObservedCallScope & {
+    observedClient: ObservedClient;
+};
+/** Scope reaching a peer connection (carries its call and client). */
+type ObservedPeerConnectionScope = ObservedClientScope & {
+    observedPeerConnection: ObservedPeerConnection;
+};
+type ObservedMediasoupRouterScope = Omit<ObserverEventBase, 'context'> & {
+    observedMediasoupRouter: ObservedMediasoupRouter;
+};
+type ObserverEvents = {
+    'observer-updated': [ObserverEventBase];
+    'observer-closed': [ObserverEventBase];
+    'sample-rejected': [ObserverEventBase & {
+        reason: SampleRejectedReason;
+        sample: ClientSample;
+    }];
+    'mediasoup-router-added': [ObservedMediasoupRouterScope];
+    'mediasoup-router-removed': [ObservedMediasoupRouterScope];
+    'mediasoup-router-matched-with-peer-connection': [ObservedMediasoupRouterScope & ObservedPeerConnectionScope];
+    'call-added': [ObservedCallScope];
+    'call-updated': [ObservedCallScope];
+    'call-closed': [ObservedCallScope];
+    'call-empty': [ObservedCallScope];
+    'call-not-empty': [ObservedCallScope];
+    'call-issue': [ObservedCallScope & {
+        issue: ClientIssue;
+    }];
+    'client-added': [ObservedClientScope];
+    'client-sink-created': [ObservedClientScope & {
+        sink: ClientSampleSink;
+    }];
+    'client-updated': [ObservedClientScope & {
+        sample: ClientSample;
+        elapsedTimeInMs: number;
+    }];
+    'client-closed': [ObservedClientScope];
+    'client-joined': [ObservedClientScope];
+    'client-left': [ObservedClientScope];
+    'client-rejoined': [ObservedClientScope & {
+        timestamp: number;
+    }];
+    'client-issue': [ObservedClientScope & {
+        issue: ClientIssue;
+    }];
+    'client-metadata': [ObservedClientScope & {
+        metaData: ClientMetaData;
+    }];
+    'client-extension-stats': [ObservedClientScope & {
+        extensionStats: ExtensionStat;
+    }];
+    'client-event': [ObservedClientScope & {
+        event: ClientEvent;
+    }];
+    'peer-connection-added': [ObservedPeerConnectionScope];
+    'peer-connection-updated': [ObservedPeerConnectionScope];
+    'peer-connection-closed': [ObservedPeerConnectionScope];
+    'ice-connection-state-changed': [ObservedPeerConnectionScope & {
+        state: string;
+    }];
+    'ice-gathering-state-changed': [ObservedPeerConnectionScope & {
+        state: string;
+    }];
+    'connection-state-changed': [ObservedPeerConnectionScope & {
+        state: string;
+    }];
+    'selected-candidate-pair-changed': [ObservedPeerConnectionScope];
+    'certificate-added': [ObservedPeerConnectionScope & {
+        observedCertificate: ObservedCertificate;
+    }];
+    'certificate-updated': [ObservedPeerConnectionScope & {
+        observedCertificate: ObservedCertificate;
+    }];
+    'certificate-removed': [ObservedPeerConnectionScope & {
+        observedCertificate: ObservedCertificate;
+    }];
+    'codec-added': [ObservedPeerConnectionScope & {
+        observedCodec: ObservedCodec;
+    }];
+    'codec-updated': [ObservedPeerConnectionScope & {
+        observedCodec: ObservedCodec;
+    }];
+    'codec-removed': [ObservedPeerConnectionScope & {
+        observedCodec: ObservedCodec;
+    }];
+    'inbound-rtp-added': [ObservedPeerConnectionScope & {
+        observedInboundRtp: ObservedInboundRtp;
+    }];
+    'inbound-rtp-updated': [ObservedPeerConnectionScope & {
+        observedInboundRtp: ObservedInboundRtp;
+    }];
+    'inbound-rtp-removed': [ObservedPeerConnectionScope & {
+        observedInboundRtp: ObservedInboundRtp;
+    }];
+    'outbound-rtp-added': [ObservedPeerConnectionScope & {
+        observedOutboundRtp: ObservedOutboundRtp;
+    }];
+    'outbound-rtp-updated': [ObservedPeerConnectionScope & {
+        observedOutboundRtp: ObservedOutboundRtp;
+    }];
+    'outbound-rtp-removed': [ObservedPeerConnectionScope & {
+        observedOutboundRtp: ObservedOutboundRtp;
+    }];
+    'remote-inbound-rtp-added': [ObservedPeerConnectionScope & {
+        observedRemoteInboundRtp: ObservedRemoteInboundRtp;
+    }];
+    'remote-inbound-rtp-updated': [ObservedPeerConnectionScope & {
+        observedRemoteInboundRtp: ObservedRemoteInboundRtp;
+    }];
+    'remote-inbound-rtp-removed': [ObservedPeerConnectionScope & {
+        observedRemoteInboundRtp: ObservedRemoteInboundRtp;
+    }];
+    'remote-outbound-rtp-added': [ObservedPeerConnectionScope & {
+        observedRemoteOutboundRtp: ObservedRemoteOutboundRtp;
+    }];
+    'remote-outbound-rtp-updated': [ObservedPeerConnectionScope & {
+        observedRemoteOutboundRtp: ObservedRemoteOutboundRtp;
+    }];
+    'remote-outbound-rtp-removed': [ObservedPeerConnectionScope & {
+        observedRemoteOutboundRtp: ObservedRemoteOutboundRtp;
+    }];
+    'data-channel-added': [ObservedPeerConnectionScope & {
+        observedDataChannel: ObservedDataChannel;
+    }];
+    'data-channel-updated': [ObservedPeerConnectionScope & {
+        observedDataChannel: ObservedDataChannel;
+    }];
+    'data-channel-removed': [ObservedPeerConnectionScope & {
+        observedDataChannel: ObservedDataChannel;
+    }];
+    'ice-candidate-added': [ObservedPeerConnectionScope & {
+        observedIceCandidate: ObservedIceCandidate;
+    }];
+    'ice-candidate-updated': [ObservedPeerConnectionScope & {
+        observedIceCandidate: ObservedIceCandidate;
+    }];
+    'ice-candidate-removed': [ObservedPeerConnectionScope & {
+        observedIceCandidate: ObservedIceCandidate;
+    }];
+    'ice-candidate-pair-added': [ObservedPeerConnectionScope & {
+        observedIceCandidatePair: ObservedIceCandidatePair;
+    }];
+    'ice-candidate-pair-updated': [ObservedPeerConnectionScope & {
+        observedIceCandidatePair: ObservedIceCandidatePair;
+    }];
+    'ice-candidate-pair-removed': [ObservedPeerConnectionScope & {
+        observedIceCandidatePair: ObservedIceCandidatePair;
+    }];
+    'ice-transport-added': [ObservedPeerConnectionScope & {
+        observedIceTransport: ObservedIceTransport;
+    }];
+    'ice-transport-updated': [ObservedPeerConnectionScope & {
+        observedIceTransport: ObservedIceTransport;
+    }];
+    'ice-transport-removed': [ObservedPeerConnectionScope & {
+        observedIceTransport: ObservedIceTransport;
+    }];
+    'media-source-added': [ObservedPeerConnectionScope & {
+        observedMediaSource: ObservedMediaSource;
+    }];
+    'media-source-updated': [ObservedPeerConnectionScope & {
+        observedMediaSource: ObservedMediaSource;
+    }];
+    'media-source-removed': [ObservedPeerConnectionScope & {
+        observedMediaSource: ObservedMediaSource;
+    }];
+    'media-playout-added': [ObservedPeerConnectionScope & {
+        observedMediaPlayout: ObservedMediaPlayout;
+    }];
+    'media-playout-updated': [ObservedPeerConnectionScope & {
+        observedMediaPlayout: ObservedMediaPlayout;
+    }];
+    'media-playout-removed': [ObservedPeerConnectionScope & {
+        observedMediaPlayout: ObservedMediaPlayout;
+    }];
+    'peer-connection-transport-added': [ObservedPeerConnectionScope & {
+        observedPeerConnectionTransport: ObservedPeerConnectionTransport;
+    }];
+    'peer-connection-transport-updated': [ObservedPeerConnectionScope & {
+        observedPeerConnectionTransport: ObservedPeerConnectionTransport;
+    }];
+    'peer-connection-transport-removed': [ObservedPeerConnectionScope & {
+        observedPeerConnectionTransport: ObservedPeerConnectionTransport;
+    }];
+    'inbound-track-added': [ObservedPeerConnectionScope & {
+        observedInboundTrack: ObservedInboundTrack;
+    }];
+    'inbound-track-updated': [ObservedPeerConnectionScope & {
+        observedInboundTrack: ObservedInboundTrack;
+    }];
+    'inbound-track-removed': [ObservedPeerConnectionScope & {
+        observedInboundTrack: ObservedInboundTrack;
+    }];
+    'inbound-track-muted': [ObservedPeerConnectionScope & {
+        observedInboundTrack: ObservedInboundTrack;
+    }];
+    'inbound-track-unmuted': [ObservedPeerConnectionScope & {
+        observedInboundTrack: ObservedInboundTrack;
+    }];
+    'outbound-track-added': [ObservedPeerConnectionScope & {
+        observedOutboundTrack: ObservedOutboundTrack;
+    }];
+    'outbound-track-updated': [ObservedPeerConnectionScope & {
+        observedOutboundTrack: ObservedOutboundTrack;
+    }];
+    'outbound-track-removed': [ObservedPeerConnectionScope & {
+        observedOutboundTrack: ObservedOutboundTrack;
+    }];
+    'outbound-track-muted': [ObservedPeerConnectionScope & {
+        observedOutboundTrack: ObservedOutboundTrack;
+    }];
+    'outbound-track-unmuted': [ObservedPeerConnectionScope & {
+        observedOutboundTrack: ObservedOutboundTrack;
+    }];
+};
+
+type ObservedClientSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
+    clientId: string;
+    appData?: AppData;
+    closeClientIfIdleForMs?: number;
+};
+type ObservedClientEvents = {
+    update: [sample: ClientSample, elapsedTimeInMs: number, context?: AcceptContext];
+    close: [];
+    joined: [];
+    left: [];
+};
+declare interface ObservedClient {
+    on<U extends keyof ObservedClientEvents>(event: U, listener: (...args: ObservedClientEvents[U]) => void): this;
+    off<U extends keyof ObservedClientEvents>(event: U, listener: (...args: ObservedClientEvents[U]) => void): this;
+    once<U extends keyof ObservedClientEvents>(event: U, listener: (...args: ObservedClientEvents[U]) => void): this;
+    emit<U extends keyof ObservedClientEvents>(event: U, ...args: ObservedClientEvents[U]): boolean;
+}
+declare class ObservedClient<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
+    readonly call: ObservedCall;
+    readonly clientId: string;
+    readonly observedPeerConnections: Map<string, ObservedPeerConnection>;
+    /** Per-client sink (from `ObserverConfig.createClientSink`), if any. */
+    readonly sink?: ClientSampleSink;
+    /** Ancestry base shared by all Observer-bus events originating at this client. */
+    readonly eventScope: ObservedClientScope;
+    readonly calculatedScore: CalculatedScore;
+    readonly settings: Pick<ObservedClientSettings, 'closeClientIfIdleForMs'>;
+    appData: AppData;
+    attachments?: Record<string, unknown>;
+    updated: number;
+    acceptedSamples: number;
+    closed: boolean;
+    joinedAt?: number;
+    leftAt?: number;
+    closedAt?: number;
+    lastSampleTimestamp?: number;
+    operationSystem?: OperationSystem;
+    engine?: Engine;
+    platform?: Platform;
+    browser?: Browser;
+    mediaConstraints: string[];
+    usingTURN: boolean;
+    usingTCP: boolean;
+    availableOutgoingBitrate: number;
+    availableIncomingBitrate: number;
+    deltaReceivedAudioBytes: number;
+    deltaReceivedVideoBytes: number;
+    deltaSentAudioBytes: number;
+    deltaSentVideoBytes: number;
+    deltaDataChannelBytesSent: number;
+    deltaDataChannelBytesReceived: number;
+    deltaDataChannelMessagesSent: number;
+    deltaDataChannelMessagesReceived: number;
+    deltaInboundPacketsLost: number;
+    deltaInboundPacketsReceived: number;
+    deltaOutboundPacketsSent: number;
+    deltaTransportSentBytes: number;
+    deltaTransportReceivedBytes: number;
+    deltaRttLt50Measurements: number;
+    deltaRttLt150Measurements: number;
+    deltaRttLt300Measurements: number;
+    deltaRttGtOrEq300Measurements: number;
+    currentMaxRttInMs?: number;
+    currentMinRttInMs?: number;
+    currentAvgRttInMs?: number;
+    sendingAudioBitrate: number;
+    sendingVideoBitrate: number;
+    receivingAudioBitrate: number;
+    receivingVideoBitrate: number;
+    numberOfInboundRtpStreams: number;
+    numberOfInbundTracks: number;
+    numberOfOutboundRtpStreams: number;
+    numberOfOutboundTracks: number;
+    numberOfDataChannels: number;
+    deltaNumberOfIssues: number;
+    totalScoreSum: number;
+    numberOfScoreMeasurements: number;
+    readonly mediaDevices: MediaDeviceInfo[];
+    issues: ClientIssue[];
+    private _injections;
+    private closeTimer?;
+    constructor(settings: ObservedClientSettings<AppData>, call: ObservedCall);
+    get numberOfPeerConnections(): number;
+    get score(): number | undefined;
+    close(): void;
+    accept(sample: ClientSample, context?: AcceptContext): void;
+    injectMetaData(metaData: ClientMetaData): void;
+    injectEvent(event: ClientEvent): void;
+    injectIssue(issue: ClientIssue): void;
+    injectExtensionStat(stat: ExtensionStat): void;
+    injectAttachment(key: string, value: unknown): void;
+    addMetadata(metadata: ClientMetaData): void;
+    addIssue(issue: ClientIssue): void;
+    addExtensionStats(stats: ExtensionStat): void;
+    private _processClientEvent;
+    private _updatePeerConnection;
+    private _mergeInjections;
+    /** Emit an Observer-bus event scoped to this client (or a peer connection under it). */
+    private _notify;
+}
+
+interface ScoreCalculator {
+    update(): void;
+}
+
+type RemoteTrackResolverFactory = (observedCall: ObservedCall) => RemoteTrackResolver;
+/**
+ * Strategy functions that map a track to its publish/subscribe identity. Two tracks are linked
+ * when a subscribed (inbound) track's **publisher id** equals a published (outbound) track's
+ * **publisher id** — one publisher → many subscribers. The **subscriber id** is optional and is
+ * only used to look an inbound track up via `getInboundTrackBySubscriberId`.
+ *
+ * The "publisher id" is whatever a strategy uses as the link key: mediasoup passes its producerId,
+ * a p2p strategy the SSRC, a generic strategy a shared attachment value.
+ */
+type RemoteTrackResolvers = {
+    /** The publisher id a subscribed (inbound) track receives. Required — this is the link key. */
+    resolveInboundTrackPublisherId: (inboundTrack: ObservedInboundTrack) => string | undefined;
+    /** The publisher id a published (outbound) track represents. Required — this is the link key. */
+    resolveOutboundTrackPublisherId: (outboundTrack: ObservedOutboundTrack) => string | undefined;
+    /** Optional: the inbound track's own subscription id (enables `getInboundTrackBySubscriberId`). */
+    resolveInboundTrackSubscriberId?: (inboundTrack: ObservedInboundTrack) => string | undefined;
+};
+/**
+ * Generic, strategy-driven base resolver. It subscribes to the Observer bus (filtered to one call),
+ * links subscribed↔published tracks by publisher id, and maintains the links directly on the tracks
+ * (`inboundTrack.remoteOutboundTrack`, `outboundTrack.remoteInboundTracks`).
+ *
+ * Concrete strategies (mediasoup, p2p-by-SSRC, generic attachment) are just different
+ * {@link RemoteTrackResolvers} passed to this class. Ids are re-resolved on demand rather than
+ * cached, so the only state kept is the two lookup indexes that back the public getters.
+ */
+declare class RemoteTrackResolver {
+    readonly observedCall: ObservedCall;
+    private readonly resolvers;
+    private readonly _publisherIdToOutboundTrack;
+    private readonly _subscriberIdToInboundTrack;
+    constructor(observedCall: ObservedCall, resolvers: RemoteTrackResolvers);
+    /** The published (outbound) track for a publisher id, if any. */
+    getOutboundTrackByPublisherId(publisherId: string): ObservedOutboundTrack | undefined;
+    /** The subscribed (inbound) track for a subscriber id, if the strategy resolves subscriber ids. */
+    getInboundTrackBySubscriberId(subscriberId: string): ObservedInboundTrack | undefined;
+    resolveRemoteOutboundTrack(inboundTrack: ObservedInboundTrack): ObservedOutboundTrack | undefined;
+    resolveRemoteInboundTracks(outboundTrack: ObservedOutboundTrack): ObservedInboundTrack[] | undefined;
+    private _addInboundTrack;
+    private _removeInboundTrack;
+    private _addOutboundTrack;
+    private _removeOutboundTrack;
+}
+
+interface Updater {
+    readonly name: string;
+    readonly description?: string;
+    close(): void;
+}
+
+interface Detector {
+    readonly name: string;
+    /** Called on every entity update; may raise issues via the entity it observes. */
+    update(): void;
+}
+
+declare class Detectors {
+    private _detectors;
+    constructor(...detectors: Detector[]);
+    get listOfNames(): string[];
+    add(detector: Detector): void;
+    remove(detector: Detector): void;
+    update(): void;
+    clear(): void;
+}
+
+type ObservedCallUpdateConfig = {
+    updatePolicy?: 'update-on-any-client-updated' | 'update-when-all-client-updated' | 'none';
+};
+type ObservedCallSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = ObservedCallUpdateConfig & {
+    callId: string;
+    appData?: AppData;
+    closeCallIfEmptyForMs?: number;
+};
+type ObservedCallEvents = {
+    update: [];
+    newclient: [ObservedClient];
+    empty: [];
+    'not-empty': [];
+    close: [];
+};
+declare interface ObservedCall {
+    on<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
+    off<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
+    once<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
+    emit<U extends keyof ObservedCallEvents>(event: U, ...args: ObservedCallEvents[U]): boolean;
+}
+declare class ObservedCall<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
+    readonly observer: Observer;
+    updater?: Updater;
+    scoreCalculator: ScoreCalculator;
+    readonly detectors: Detectors;
+    readonly callId: string;
+    readonly observedClients: Map<string, ObservedClient<Record<string, unknown>>>;
+    readonly clientsUsedTurn: Set<string>;
+    readonly calculatedScore: CalculatedScore;
+    remoteTrackResolver?: RemoteTrackResolver;
+    totalAddedClients: number;
+    totalRemovedClients: number;
+    numberOfIssues: number;
+    numberOfPeerConnections: number;
+    numberOfInboundRtpStreams: number;
+    numberOfOutboundRtpStreams: number;
+    numberOfDataChannels: number;
+    maxNumberOfClients: number;
+    deltaNumberOfIssues: number;
+    appData: AppData;
+    closed: boolean;
+    startedAt?: number;
+    endedAt?: number;
+    closedAt?: number;
+    readonly settings: Pick<ObservedCallSettings, 'closeCallIfEmptyForMs'>;
+    /** Ancestry base shared by all Observer-bus events originating at this call. */
+    readonly eventScope: ObservedCallScope;
+    private closeTimer?;
+    constructor(settings: ObservedCallSettings<AppData>, observer: Observer);
+    get numberOfClients(): number;
+    get score(): number | undefined;
+    /** Raise a call-level (server-side) issue; surfaced on the Observer bus as `call-issue`. */
+    addIssue(issue: ClientIssue): void;
+    close(): void;
+    getObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(clientId: string): ObservedClient<ClientAppData> | undefined;
+    createObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedClientSettings<ClientAppData>): ObservedClient<ClientAppData> | undefined;
+    getOrCreateObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedClientSettings<ClientAppData>): ObservedClient<ClientAppData> | undefined;
+    update(context?: AcceptContext): void;
+    private _onClientUpdate;
+    private _clientJoined;
+    private _clientLeft;
+    /** Emit an Observer-bus event scoped to this call. */
+    private _notify;
+}
+
+type Middleware<T> = (input: T, next: (nextInput: T) => void) => void;
+interface Processor<T> {
+    finalCallback?: Callback<T>;
+    process(value: T): void;
+    addMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
+    removeMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
+}
+type Callback<T> = (input: T) => void;
+declare class MiddlewareProcessor<T> implements Processor<T> {
+    private stack;
+    finalCallback?: Callback<T>;
+    addMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
+    removeMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
+    process(value: T): void;
+}
+
+type SampleRejectedReason = 'observer-closed' | 'missing-callId' | 'missing-clientId';
+
+/**
+ * Optional, free-form context supplied to `accept()`. A single context object is
+ * threaded down the accept chain (Observer -> Client -> PeerConnection) and is
+ * merged into the `appData` of entities created during the accept pass.
+ */
+type AcceptContext = Record<string, unknown>;
+/** The payload threaded through `accept()` middlewares: the sample and its optional context. */
+type AcceptMiddlewarePayload = {
+    sample: ClientSample;
+    context?: AcceptContext;
+};
+/**
+ * A global middleware run on every sample passed to `observer.accept()`, in registration order,
+ * **before** the sample is dispatched to any call/client. It may inspect or mutate the sample
+ * (e.g. set/normalize `callId`/`clientId`, enrich, redact) or the context, then call
+ * `next(payload)` to continue the chain. Not calling `next` **drops** the sample.
+ */
+type AcceptMiddleware = Middleware<AcceptMiddlewarePayload>;
+type ObserverUpdateConfig = {
+    updatePolicy?: 'update-on-any-call-updated' | 'update-when-all-call-updated' | 'none';
+};
+/** Produces the initial `appData` for a call created without an explicit `appData`. */
+type CallAppDataFactory = (params: {
+    callId: string;
+    observer: Observer;
+}) => Record<string, unknown>;
+/** Produces the initial `appData` for a client created without an explicit `appData`. */
+type ClientAppDataFactory = (params: {
+    clientId: string;
+    observedCall: ObservedCall;
+}) => Record<string, unknown>;
+type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unknown>> = ObserverUpdateConfig & {
+    defaultCallUpdatePolicy?: ObservedCallSettings['updatePolicy'];
+    appData?: AppData;
+    closeClientIfIdleForMs?: number;
+    closeCallIfEmptyForMs?: number;
+    /**
+     * Optional factory invoked when a call is created without an explicit `appData`
+     * (e.g. lazily by `accept()`), so apps can enrich appData without pre-creating the
+     * entity. `appData` is application-owned; it is never modified by the `accept()` context.
+     */
+    createCallAppData?: CallAppDataFactory;
+    /** Same as `createCallAppData`, for clients. Receives the (already-created) parent call. */
+    createClientAppData?: ClientAppDataFactory;
+    /**
+     * Optional factory invoked when a client is created, producing a per-client sink that
+     * receives every sample the client accepts (or `undefined` for no sink). The destination
+     * can be derived from `callId` / `clientId`.
+     */
+    createClientSink?: ClientSampleSinkFactory;
+    /**
+     * Optional factory invoked when a call is created, producing the call's `RemoteTrackResolver`
+     * (or `undefined` for none). Use the built-ins
+     * (`createDefaultMediasoupRemoteTrackResolverFactory()` / `createP2pRemoteTrackResolverFactory()`)
+     * or build a `RemoteTrackResolver` with custom publisher/subscriber id resolvers.
+     */
+    createTrackResolver?: RemoteTrackResolverFactory;
+};
+declare interface Observer {
+    on<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;
+    off<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;
+    once<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;
+    emit<U extends keyof ObserverEvents>(event: U, ...args: ObserverEvents[U]): boolean;
+}
+declare class Observer<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
+    readonly config: ObserverConfig<AppData>;
+    readonly observedTURN: ObservedTURN;
+    readonly observedCalls: Map<string, ObservedCall<Record<string, unknown>>>;
+    readonly observedMediasoupRouters: Map<string, ObservedMediasoupRouter<Record<string, unknown>>>;
+    updater?: Updater;
+    /** Ancestry base shared by all Observer-bus events originating at the observer. */
+    readonly eventScope: ObserverEventBase;
+    closed: boolean;
+    totalAddedCall: number;
+    totalRemovedCall: number;
+    numberOfClientsUsingTurn: number;
+    numberOfClients: number;
+    numberOfInboundRtpStreams: number;
+    numberOfOutboundRtpStreams: number;
+    numberOfDataChannels: number;
+    numberOfPeerConnections: number;
+    /** Global, pre-dispatch middleware chain run on every accepted sample. */
+    readonly acceptMiddlewares: MiddlewareProcessor<AcceptMiddlewarePayload>;
+    constructor(config?: ObserverConfig<AppData>);
+    get numberOfCalls(): number;
+    get appData(): AppData | undefined;
+    getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined;
+    createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;
+    getOrCreateObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;
+    createObservedMediasoupRouter<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedMediasoupRouterSettings<T>): ObservedMediasoupRouter<Record<string, unknown>> | undefined;
+    close(): void;
+    accept(sample: ClientSample, context?: AcceptContext): void;
+    update(): void;
+    /** Emit an Observer-bus event. */
+    private _notify;
+}
+
+declare enum ClientEventTypes {
+    CLIENT_JOINED = "CLIENT_JOINED",
+    CLIENT_LEFT = "CLIENT_LEFT",
+    PEER_CONNECTION_OPENED = "PEER_CONNECTION_OPENED",
+    PEER_CONNECTION_CLOSED = "PEER_CONNECTION_CLOSED",
+    MEDIA_TRACK_ADDED = "MEDIA_TRACK_ADDED",
+    MEDIA_TRACK_REMOVED = "MEDIA_TRACK_REMOVED",
+    MEDIA_TRACK_RESUMED = "MEDIA_TRACK_RESUMED",
+    MEDIA_TRACK_MUTED = "MEDIA_TRACK_MUTED",
+    MEDIA_TRACK_UNMUTED = "MEDIA_TRACK_UNMUTED",
+    ICE_GATHERING_STATE_CHANGED = "ICE_GATHERING_STATE_CHANGED",
+    PEER_CONNECTION_STATE_CHANGED = "PEER_CONNECTION_STATE_CHANGED",
+    ICE_CONNECTION_STATE_CHANGED = "ICE_CONNECTION_STATE_CHANGED",
+    DATA_CHANNEL_OPEN = "DATA_CHANNEL_OPEN",
+    DATA_CHANNEL_CLOSED = "DATA_CHANNEL_CLOSED",
+    DATA_CHANNEL_ERROR = "DATA_CHANNEL_ERROR",
+    NEGOTIATION_NEEDED = "NEGOTIATION_NEEDED",
+    SIGNALING_STATE_CHANGE = "SIGNALING_STATE_CHANGE",
+    ICE_CANDIDATE = "ICE_CANDIDATE",
+    ICE_CANDIDATE_ERROR = "ICE_CANDIDATE_ERROR",
+    PRODUCER_ADDED = "PRODUCER_ADDED",
+    PRODUCER_REMOVED = "PRODUCER_REMOVED",
+    PRODUCER_PAUSED = "PRODUCER_PAUSED",
+    PRODUCER_RESUMED = "PRODUCER_RESUMED",
+    CONSUMER_ADDED = "CONSUMER_ADDED",
+    CONSUMER_REMOVED = "CONSUMER_REMOVED",
+    CONSUMER_PAUSED = "CONSUMER_PAUSED",
+    CONSUMER_RESUMED = "CONSUMER_RESUMED",
+    DATA_PRODUCER_CREATED = "DATA_PRODUCER_CREATED",
+    DATA_PRODUCER_CLOSED = "DATA_PRODUCER_CLOSED",
+    DATA_CONSUMER_CREATED = "DATA_CONSUMER_CREATED",
+    DATA_CONSUMER_CLOSED = "DATA_CONSUMER_CLOSED"
+}
+
+interface Logger {
+    trace(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+interface ObserverLogger {
+    trace(module: string, ...args: any[]): void;
+    debug(module: string, ...args: any[]): void;
+    info(module: string, ...args: any[]): void;
+    warn(module: string, ...args: any[]): void;
+    error(module: string, ...args: any[]): void;
+}
+declare function createLogger(moduleName: string): Logger;
+declare function setObserverLogger(logger: ObserverLogger): void;
+
+type JsonlFileSinkOptions = {
+    /** Absolute or relative file path to append JSONL lines to. */
+    path: string;
+    /** Optional custom serializer; defaults to `JSON.stringify`. */
+    serializeSample?: (sample: ClientSample) => string;
+};
+/**
+ * A sink that serializes each sample to a JSON line and appends it to a file. It wraps an
+ * `fs.WriteStream` and re-emits its lifecycle events, so `close` fires once the file is flushed
+ * and its descriptor is closed (file ready) and `error` surfaces file errors.
+ */
+declare class JsonlFileSink extends ClientSampleSink {
+    /** The file this sink writes to. Read it (e.g. in a `close` handler) to upload/move the file. */
+    readonly path: string;
+    private readonly _stream;
+    private readonly _serializeSample;
+    constructor(options: JsonlFileSinkOptions);
+    write(sample: ClientSample): boolean;
+    end(): void;
+}
+/** Build a JSONL file sink for a single path. */
+declare function createJsonlFileSink(options: JsonlFileSinkOptions): ClientSampleSink;
+type JsonlFileSinkFactoryOptions = {
+    /** Directory the per-client files are written into (must exists). */
+    directory: string;
+    /** Builds the file name from the call/client ids. Defaults to `${callId}__${clientId}.jsonl`. */
+    getFileName?: (params: {
+        callId: string;
+        clientId: string;
+    }) => string;
+    /** Optional custom serializer; defaults to `JSON.stringify`. */
+    serializeSample?: (sample: ClientSample) => string;
+};
+/**
+ * Convenience factory that writes one JSONL file per client, with the path derived from
+ * `callId` / `clientId`. Plug into `ObserverConfig.createClientSink`.
+ */
+declare function createJsonlFileSinkFactory(options: JsonlFileSinkFactoryOptions): ClientSampleSinkFactory;
+
+/**
+ * A `ClientSampleSink` that collects the accepted sample objects into an array. Useful for
+ * tests and offline replay. Emits `close` on `end()`.
+ */
+declare class InMemorySink extends ClientSampleSink {
+    readonly samples: ClientSample[];
+    constructor(samples?: ClientSample[]);
+    write(sample: ClientSample): boolean;
+    end(): void;
+}
+declare function createInMemorySink(samples?: ClientSample[]): InMemorySink;
+
+declare function createDefaultMediasoupRemoteTrackResolverFactory(): RemoteTrackResolverFactory;
+declare function createP2pRemoteTrackResolverFactory(): RemoteTrackResolverFactory;
+
+export { type AcceptContext, type AcceptMiddleware, type AcceptMiddlewarePayload, type CallAppDataFactory, type ClientAppDataFactory, type ClientEvent, ClientEventTypes, type ClientIssue, type ClientMetaData, ClientMetaTypes, type ClientSample, ClientSampleSink, type ClientSampleSinkEvents, type ClientSampleSinkFactory, type Detector, Detectors, InMemorySink, JsonlFileSink, type JsonlFileSinkFactoryOptions, type JsonlFileSinkOptions, type Logger, type MediasoupConsumerSample, type MediasoupConsumerSampleEvent, type MediasoupDataConsumerSample, type MediasoupDataProducerSample, type MediasoupDirectTransportSample, type MediasoupDirectTransportSampleEventMap, type MediasoupPipeTransportSample, type MediasoupPipeTransportSampleEventMap, type MediasoupPlainTransportSample, type MediasoupPlainTransportSampleEventMap, type MediasoupProducerSample, type MediasoupProducerSampleEvent, type MediasoupRouterSample, type MediasoupTransportSample, type MediasoupWebRtcTransportSample, type MediasoupWebRtcTransportSampleEventMap, type Middleware, ObservedCall, type ObservedCallScope, ObservedCertificate, ObservedClient, type ObservedClientScope, ObservedCodec, ObservedDataChannel, ObservedIceCandidate, ObservedIceCandidatePair, ObservedIceTransport, ObservedInboundRtp, ObservedInboundTrack, ObservedMediaPlayout, ObservedMediaSource, ObservedMediasoupRouter, type ObservedMediasoupRouterEvents, type ObservedMediasoupRouterScope, type ObservedMediasoupRouterSettings, ObservedOutboundRtp, ObservedOutboundTrack, ObservedPeerConnection, type ObservedPeerConnectionScope, ObservedPeerConnectionTransport, ObservedRemoteInboundRtp, ObservedRemoteOutboundRtp, Observer, type ObserverEventBase, type ObserverEvents, type ObserverLogger, RemoteTrackResolver, type RemoteTrackResolverFactory, type RemoteTrackResolvers, type SampleRejectedReason, type ScoreCalculator, createDefaultMediasoupRemoteTrackResolverFactory, createInMemorySink, createJsonlFileSink, createJsonlFileSinkFactory, createLogger, createP2pRemoteTrackResolverFactory, setObserverLogger };