@observertc/observer-js 1.0.1-c3edea3.0 → 1.0.1-c665f5a.0

package/lib/ObserverEventMonitor.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObserverEventMonitor = void 0;
+class ObserverEventMonitor {
+    observer;
+    context;
+    constructor(observer, context) {
+        this.observer = observer;
+        this.context = context;
+        this._onPeerConnconnectionAdded = this._onPeerConnconnectionAdded.bind(this);
+        this._onPeerConnectionRemoved = this._onPeerConnectionRemoved.bind(this);
+        this._onCertificateAdded = this._onCertificateAdded.bind(this);
+        this._onCertificateRemoved = this._onCertificateRemoved.bind(this);
+        this._onInboundTrackAdded = this._onInboundTrackAdded.bind(this);
+        this._onInboundTrackRemoved = this._onInboundTrackRemoved.bind(this);
+        this._onOutboundTrackAdded = this._onOutboundTrackAdded.bind(this);
+        this._onOutboundTrackRemoved = this._onOutboundTrackRemoved.bind(this);
+        this._onOutboundTrackMuted = this._onOutboundTrackMuted.bind(this);
+        this._onOutboundTrackUnmuted = this._onOutboundTrackUnmuted.bind(this);
+        this._onInboundRtpAdded = this._onInboundRtpAdded.bind(this);
+        this._onInboundRtpRemoved = this._onInboundRtpRemoved.bind(this);
+        this._onInboundRtpUpdated = this._onInboundRtpUpdated.bind(this);
+        this._onOutboundTrackUpdated = this._onOutboundTrackUpdated.bind(this);
+        this._onInboundTrackUpdated = this._onInboundTrackUpdated.bind(this);
+        this._onOutboundRtpAdded = this._onOutboundRtpAdded.bind(this);
+        this._onOutboundRtpRemoved = this._onOutboundRtpRemoved.bind(this);
+        this._onDataChannelAdded = this._onDataChannelAdded.bind(this);
+        this._onDataChannelRemoved = this._onDataChannelRemoved.bind(this);
+        this._onAddedIceTransport = this._onAddedIceTransport.bind(this);
+        this._onRemovedIceTransport = this._onRemovedIceTransport.bind(this);
+        this._onIceCandidateAdded = this._onIceCandidateAdded.bind(this);
+        this._onIceCandidateRemoved = this._onIceCandidateRemoved.bind(this);
+        this._onAddedIceCandidatePair = this._onAddedIceCandidatePair.bind(this);
+        this._onRemovedIceCandidatePair = this._onRemovedIceCandidatePair.bind(this);
+        this._onAddedMediaCodec = this._onAddedMediaCodec.bind(this);
+        this._onRemovedMediaCodec = this._onRemovedMediaCodec.bind(this);
+        this._onAddedMediaPlayout = this._onAddedMediaPlayout.bind(this);
+        this._onRemovedMediaPlayout = this._onRemovedMediaPlayout.bind(this);
+        this._onMediaSourceAdded = this._onMediaSourceAdded.bind(this);
+        this._onMediaSourceRemoved = this._onMediaSourceRemoved.bind(this);
+        this._onClientIssue = this._onClientIssue.bind(this);
+        this._onClientMetadata = this._onClientMetadata.bind(this);
+        this._onClientJoined = this._onClientJoined.bind(this);
+        this._onClientLeft = this._onClientLeft.bind(this);
+        this._onUserMediaError = this._onUserMediaError.bind(this);
+        this._onUsingTurn = this._onUsingTurn.bind(this);
+        this._onClientAdded = this._onClientAdded.bind(this);
+        this._onCallAdded = this._onCallAdded.bind(this);
+        this._onClientRejoined = this._onClientRejoined.bind(this);
+        this._onClientExtensionStats = this._onClientExtensionStats.bind(this);
+        this._onCertificateUpdated = this._onCertificateUpdated.bind(this);
+        this._onInboundRtpUpdated = this._onInboundRtpUpdated.bind(this);
+        this._onOutboundRtpUpdated = this._onOutboundRtpUpdated.bind(this);
+        this._onInboundTrackUpdated = this._onInboundTrackUpdated.bind(this);
+        this._onOutboundTrackUpdated = this._onOutboundTrackUpdated.bind(this);
+        this._onDataChannelUpdated = this._onDataChannelUpdated.bind(this);
+        this._onIceTransportUpdated = this._onIceTransportUpdated.bind(this);
+        this._onIceCandidatePairUpdated = this._onIceCandidatePairUpdated.bind(this);
+        this._onMediaCodecUpdated = this._onMediaCodecUpdated.bind(this);
+        this._onMediaPlayoutUpdated = this._onMediaPlayoutUpdated.bind(this);
+        this._onMediaSourceUpdated = this._onMediaSourceUpdated.bind(this);
+        this._onIceCandidateUpdated = this._onIceCandidateUpdated.bind(this);
+        this.observer.once('close', () => {
+            this.observer.off('newcall', this._onCallAdded);
+        });
+        this.observer.on('newcall', this._onCallAdded);
+    }
+    // Public event handlers
+    onCallAdded;
+    onCallRemoved;
+    onCallEmpty;
+    onCallNotEmpty;
+    onCallUpdated;
+    onClientAdded;
+    onClientClosed;
+    onClientRejoined;
+    onClientIssue;
+    onClientMetadata;
+    onClientExtensionStats;
+    onClientJoined;
+    onClientLeft;
+    onClientUserMediaError;
+    onClientUsingTurn;
+    onClientUpdated;
+    onClientEvent;
+    onPeerConnectionAdded;
+    onPeerConnectionRemoved;
+    onSelectedCandidatePairChanged;
+    onIceGatheringStateChange;
+    onIceConnectionStateChange;
+    onConnectionStateChange;
+    onCertificateAdded;
+    onCertificateRemoved;
+    onCertificateUpdated;
+    onInboundTrackAdded;
+    onInboundTrackRemoved;
+    onInboundTrackUpdated;
+    onInboundTrackMuted;
+    onInboundTrackUnmuted;
+    onOutboundTrackAdded;
+    onOutboundTrackRemoved;
+    onOutboundTrackUpdated;
+    onOutboundTrackMuted;
+    onOutboundTrackUnmuted;
+    onInboundRtpAdded;
+    onInboundRtpRemoved;
+    onInboundRtpUpdated;
+    onOutboundRtpAdded;
+    onOutboundRtpRemoved;
+    onOutboundRtpUpdated;
+    onDataChannelAdded;
+    onDataChannelRemoved;
+    onDataChannelUpdated;
+    onAddedIceTransport;
+    onRemovedIceTransport;
+    onIceTransportUpdated;
+    onIceCandidateAdded;
+    onIceCandidateRemoved;
+    onIceCandidateUpdated;
+    onAddedIceCandidatePair;
+    onRemovedIceCandidatePair;
+    onIceCandidatePairUpdated;
+    onAddedMediaCodec;
+    onRemovedMediaCodec;
+    onMediaCodecUpdated;
+    onAddedMediaPlayout;
+    onRemovedMediaPlayout;
+    onMediaPlayoutUpdated;
+    onMediaSourceAdded;
+    onMediaSourceRemoved;
+    onMediaSourceUpdated;
+    _onCallAdded(call) {
+        const onCallEmpty = () => this.onCallEmpty?.(call, this.context);
+        const onCallNotEmpty = () => this.onCallNotEmpty?.(call, this.context);
+        const onCallUpdated = () => this.onCallUpdated?.(call, this.context);
+        call.once('close', () => {
+            call.off('newclient', this._onClientAdded);
+            call.off('empty', onCallEmpty);
+            call.off('not-empty', onCallNotEmpty);
+            call.off('update', onCallUpdated);
+            this.onCallRemoved?.(call, this.context);
+        });
+        call.on('newclient', this._onClientAdded);
+        call.on('empty', onCallEmpty);
+        call.on('not-empty', onCallNotEmpty);
+        call.on('update', onCallUpdated);
+        this.onCallAdded?.(call, this.context);
+    }
+    _onClientAdded(observedClient) {
+        const onClientIssue = (issue) => this._onClientIssue(observedClient, issue);
+        const onClientMetadata = (metaData) => this._onClientMetadata(observedClient, metaData);
+        const onClientJoined = () => this._onClientJoined(observedClient);
+        const onClientLeft = () => this._onClientLeft(observedClient);
+        const onClientRejoined = () => this._onClientRejoined(observedClient);
+        const onClientExtensionStats = (extensionStats) => this._onClientExtensionStats(observedClient, extensionStats);
+        const onUsingTurn = (usingTurn) => this._onUsingTurn(observedClient, usingTurn);
+        const onUserMediaError = (error) => this._onUserMediaError(observedClient, error);
+        const onClientUpdated = (...args) => this.onClientUpdated?.(observedClient, args[0], this.context);
+        const onClientEvent = (event) => this.onClientEvent?.(observedClient, event, this.context);
+        observedClient.once('close', () => {
+            observedClient.off('newpeerconnection', this._onPeerConnconnectionAdded);
+            observedClient.off('issue', onClientIssue);
+            observedClient.off('metaData', onClientMetadata);
+            observedClient.off('joined', onClientJoined);
+            observedClient.off('left', onClientLeft);
+            observedClient.off('rejoined', onClientJoined);
+            observedClient.off('usermediaerror', onUserMediaError);
+            observedClient.off('usingturn', onUsingTurn);
+            observedClient.off('extensionStats', onClientExtensionStats);
+            observedClient.off('update', onClientUpdated);
+            observedClient.off('clientEvent', onClientEvent);
+            this.onClientClosed?.(observedClient, this.context);
+        });
+        observedClient.on('newpeerconnection', this._onPeerConnconnectionAdded);
+        observedClient.on('issue', onClientIssue);
+        observedClient.on('metaData', onClientMetadata);
+        observedClient.on('joined', onClientJoined);
+        observedClient.on('left', onClientLeft);
+        observedClient.on('rejoined', onClientRejoined);
+        observedClient.on('usermediaerror', onUserMediaError);
+        observedClient.on('usingturn', onUsingTurn);
+        observedClient.on('extensionStats', onClientExtensionStats);
+        observedClient.on('update', onClientUpdated);
+        observedClient.on('clientEvent', onClientEvent);
+        this.onClientAdded?.(observedClient, this.context);
+    }
+    _onClientRejoined(observedClient) {
+        this.onClientRejoined?.(observedClient, this.context);
+    }
+    _onPeerConnconnectionAdded(peerConnection) {
+        const onSelectedCandidatePairChanged = () => this.onSelectedCandidatePairChanged?.(peerConnection, this.context);
+        const onIceGatheringStateChange = () => this.onIceGatheringStateChange?.(peerConnection, this.context);
+        const onIceConnectionStateChange = () => this.onIceConnectionStateChange?.(peerConnection, this.context);
+        const onConnectionStateChange = () => this.onConnectionStateChange?.(peerConnection, this.context);
+        peerConnection.once('close', () => {
+            peerConnection.off('added-certificate', this._onCertificateAdded);
+            peerConnection.off('removed-certificate', this._onCertificateRemoved);
+            peerConnection.off('updated-certificate', this._onCertificateUpdated);
+            peerConnection.off('added-inbound-track', this._onInboundTrackAdded);
+            peerConnection.off('removed-inbound-track', this._onInboundTrackRemoved);
+            peerConnection.off('updated-inbound-track', this._onInboundTrackUpdated);
+            peerConnection.off('muted-inbound-track', this._onInboundTrackMuted);
+            peerConnection.off('unmuted-inbound-track', this._onInboundTrackUnmuted);
+            peerConnection.off('added-outbound-track', this._onOutboundTrackAdded);
+            peerConnection.off('removed-outbound-track', this._onOutboundTrackRemoved);
+            peerConnection.off('updated-outbound-track', this._onOutboundTrackUpdated);
+            peerConnection.off('muted-outbound-track', this._onOutboundTrackMuted);
+            peerConnection.off('unmuted-outbound-track', this._onOutboundTrackUnmuted);
+            peerConnection.off('added-inbound-rtp', this._onInboundRtpAdded);
+            peerConnection.off('removed-inbound-rtp', this._onInboundRtpRemoved);
+            peerConnection.off('updated-inbound-rtp', this._onInboundRtpUpdated);
+            peerConnection.off('added-outbound-rtp', this._onOutboundRtpAdded);
+            peerConnection.off('removed-outbound-rtp', this._onOutboundRtpRemoved);
+            peerConnection.off('updated-outbound-rtp', this._onOutboundRtpUpdated);
+            peerConnection.off('added-data-channel', this._onDataChannelAdded);
+            peerConnection.off('removed-data-channel', this._onDataChannelRemoved);
+            peerConnection.off('updated-data-channel', this._onDataChannelUpdated);
+            peerConnection.off('added-ice-transport', this._onAddedIceTransport);
+            peerConnection.off('removed-ice-transport', this._onRemovedIceTransport);
+            peerConnection.off('updated-ice-transport', this._onIceTransportUpdated);
+            peerConnection.off('added-ice-candidate', this._onIceCandidateAdded);
+            peerConnection.off('removed-ice-candidate', this._onIceCandidateRemoved);
+            peerConnection.off('updated-ice-candidate', this._onIceCandidateUpdated);
+            peerConnection.off('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+            peerConnection.off('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+            peerConnection.off('updated-ice-candidate-pair', this._onIceCandidatePairUpdated);
+            peerConnection.off('added-codec', this._onAddedMediaCodec);
+            peerConnection.off('removed-codec', this._onRemovedMediaCodec);
+            peerConnection.off('updated-codec', this._onMediaCodecUpdated);
+            peerConnection.off('added-media-playout', this._onAddedMediaPlayout);
+            peerConnection.off('removed-media-playout', this._onRemovedMediaPlayout);
+            peerConnection.off('updated-media-playout', this._onMediaPlayoutUpdated);
+            peerConnection.off('added-media-source', this._onMediaSourceAdded);
+            peerConnection.off('removed-media-source', this._onMediaSourceRemoved);
+            peerConnection.off('updated-media-source', this._onMediaSourceUpdated);
+            peerConnection.off('selectedcandidatepair', onSelectedCandidatePairChanged);
+            peerConnection.off('icegatheringstatechange', onIceGatheringStateChange);
+            peerConnection.off('iceconnectionstatechange', onIceConnectionStateChange);
+            peerConnection.off('connectionstatechange', onConnectionStateChange);
+            this.onPeerConnectionRemoved?.(peerConnection, this.context);
+        });
+        peerConnection.on('added-certificate', this._onCertificateAdded);
+        peerConnection.on('removed-certificate', this._onCertificateRemoved);
+        peerConnection.on('updated-certificate', this._onCertificateUpdated);
+        peerConnection.on('added-inbound-track', this._onInboundTrackAdded);
+        peerConnection.on('removed-inbound-track', this._onInboundTrackRemoved);
+        peerConnection.on('updated-inbound-track', this._onInboundTrackUpdated);
+        peerConnection.on('muted-inbound-track', this._onInboundTrackMuted);
+        peerConnection.on('unmuted-inbound-track', this._onInboundTrackUnmuted);
+        peerConnection.on('added-outbound-track', this._onOutboundTrackAdded);
+        peerConnection.on('removed-outbound-track', this._onOutboundTrackRemoved);
+        peerConnection.on('updated-outbound-track', this._onOutboundTrackUpdated);
+        peerConnection.on('muted-outbound-track', this._onOutboundTrackMuted);
+        peerConnection.on('unmuted-outbound-track', this._onOutboundTrackUnmuted);
+        peerConnection.on('added-inbound-rtp', this._onInboundRtpAdded);
+        peerConnection.on('removed-inbound-rtp', this._onInboundRtpRemoved);
+        peerConnection.on('updated-inbound-rtp', this._onInboundRtpUpdated);
+        peerConnection.on('added-outbound-rtp', this._onOutboundRtpAdded);
+        peerConnection.on('removed-outbound-rtp', this._onOutboundRtpRemoved);
+        peerConnection.on('updated-outbound-rtp', this._onOutboundRtpUpdated);
+        peerConnection.on('added-data-channel', this._onDataChannelAdded);
+        peerConnection.on('removed-data-channel', this._onDataChannelRemoved);
+        peerConnection.on('updated-data-channel', this._onDataChannelUpdated);
+        peerConnection.on('added-ice-transport', this._onAddedIceTransport);
+        peerConnection.on('removed-ice-transport', this._onRemovedIceTransport);
+        peerConnection.on('updated-ice-transport', this._onIceTransportUpdated);
+        peerConnection.on('added-ice-candidate', this._onIceCandidateAdded);
+        peerConnection.on('removed-ice-candidate', this._onIceCandidateRemoved);
+        peerConnection.on('updated-ice-candidate', this._onIceCandidateUpdated);
+        peerConnection.on('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+        peerConnection.on('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+        peerConnection.on('updated-ice-candidate-pair', this._onIceCandidatePairUpdated);
+        peerConnection.on('added-codec', this._onAddedMediaCodec);
+        peerConnection.on('removed-codec', this._onRemovedMediaCodec);
+        peerConnection.on('updated-codec', this._onMediaCodecUpdated);
+        peerConnection.on('added-media-playout', this._onAddedMediaPlayout);
+        peerConnection.on('removed-media-playout', this._onRemovedMediaPlayout);
+        peerConnection.on('updated-media-playout', this._onMediaPlayoutUpdated);
+        peerConnection.on('added-media-source', this._onMediaSourceAdded);
+        peerConnection.on('removed-media-source', this._onMediaSourceRemoved);
+        peerConnection.on('updated-media-source', this._onMediaSourceUpdated);
+        peerConnection.on('selectedcandidatepair', onSelectedCandidatePairChanged);
+        peerConnection.on('icegatheringstatechange', onIceGatheringStateChange);
+        peerConnection.on('iceconnectionstatechange', onIceConnectionStateChange);
+        peerConnection.on('connectionstatechange', onConnectionStateChange);
+        this.onPeerConnectionAdded?.(peerConnection, this.context);
+    }
+    _onPeerConnectionRemoved(peerConnection) {
+        this.onPeerConnectionRemoved?.(peerConnection, this.context);
+    }
+    _onCertificateAdded(certificate) {
+        this.onCertificateAdded?.(certificate, this.context);
+    }
+    _onCertificateRemoved(certificate) {
+        this.onCertificateRemoved?.(certificate, this.context);
+    }
+    _onCertificateUpdated(certificate) {
+        this.onCertificateUpdated?.(certificate, this.context);
+    }
+    _onInboundTrackAdded(inboundTrack) {
+        this.onInboundTrackAdded?.(inboundTrack, this.context);
+    }
+    _onInboundTrackRemoved(inboundTrack) {
+        this.onInboundTrackRemoved?.(inboundTrack, this.context);
+    }
+    _onInboundTrackUpdated(inboundTrack) {
+        this.onInboundTrackUpdated?.(inboundTrack, this.context);
+    }
+    _onOutboundTrackMuted(outboundTrack) {
+        this.onOutboundTrackMuted?.(outboundTrack, this.context);
+    }
+    _onOutboundTrackUnmuted(outboundTrack) {
+        this.onOutboundTrackUnmuted?.(outboundTrack, this.context);
+    }
+    _onOutboundTrackAdded(outboundTrack) {
+        this.onOutboundTrackAdded?.(outboundTrack, this.context);
+    }
+    _onOutboundTrackRemoved(outboundTrack) {
+        this.onOutboundTrackRemoved?.(outboundTrack, this.context);
+    }
+    _onOutboundTrackUpdated(outboundTrack) {
+        this.onOutboundTrackUpdated?.(outboundTrack, this.context);
+    }
+    _onInboundTrackMuted(inboundTrack) {
+        this.onInboundTrackMuted?.(inboundTrack, this.context);
+    }
+    _onInboundTrackUnmuted(inboundTrack) {
+        this.onInboundTrackUnmuted?.(inboundTrack, this.context);
+    }
+    _onInboundRtpAdded(inboundRtp) {
+        this.onInboundRtpAdded?.(inboundRtp, this.context);
+    }
+    _onInboundRtpRemoved(inboundRtp) {
+        this.onInboundRtpRemoved?.(inboundRtp, this.context);
+    }
+    _onInboundRtpUpdated(inboundRtp) {
+        this.onInboundRtpUpdated?.(inboundRtp, this.context);
+    }
+    _onOutboundRtpAdded(outboundRtp) {
+        this.onOutboundRtpAdded?.(outboundRtp, this.context);
+    }
+    _onOutboundRtpRemoved(outboundRtp) {
+        this.onOutboundRtpRemoved?.(outboundRtp, this.context);
+    }
+    _onOutboundRtpUpdated(outboundRtp) {
+        this.onOutboundRtpUpdated?.(outboundRtp, this.context);
+    }
+    _onDataChannelAdded(dataChannel) {
+        this.onDataChannelAdded?.(dataChannel, this.context);
+    }
+    _onDataChannelRemoved(dataChannel) {
+        this.onDataChannelRemoved?.(dataChannel, this.context);
+    }
+    _onDataChannelUpdated(dataChannel) {
+        this.onDataChannelUpdated?.(dataChannel, this.context);
+    }
+    _onAddedIceTransport(iceTransport) {
+        this.onAddedIceTransport?.(iceTransport, this.context);
+    }
+    _onRemovedIceTransport(iceTransport) {
+        this.onRemovedIceTransport?.(iceTransport, this.context);
+    }
+    _onIceTransportUpdated(iceTransport) {
+        this.onIceTransportUpdated?.(iceTransport, this.context);
+    }
+    _onIceCandidateAdded(iceCandidate) {
+        this.onIceCandidateAdded?.(iceCandidate, this.context);
+    }
+    _onIceCandidateRemoved(iceCandidate) {
+        this.onIceCandidateRemoved?.(iceCandidate, this.context);
+    }
+    _onIceCandidateUpdated(iceCandidate) {
+        this.onIceCandidateUpdated?.(iceCandidate, this.context);
+    }
+    _onAddedIceCandidatePair(candidatePair) {
+        this.onAddedIceCandidatePair?.(candidatePair, this.context);
+    }
+    _onRemovedIceCandidatePair(candidatePair) {
+        this.onRemovedIceCandidatePair?.(candidatePair, this.context);
+    }
+    _onIceCandidatePairUpdated(candidatePair) {
+        this.onIceCandidatePairUpdated?.(candidatePair, this.context);
+    }
+    _onAddedMediaCodec(codec) {
+        this.onAddedMediaCodec?.(codec, this.context);
+    }
+    _onRemovedMediaCodec(codec) {
+        this.onRemovedMediaCodec?.(codec, this.context);
+    }
+    _onMediaCodecUpdated(codec) {
+        this.onMediaCodecUpdated?.(codec, this.context);
+    }
+    _onAddedMediaPlayout(mediaPlayout) {
+        this.onAddedMediaPlayout?.(mediaPlayout, this.context);
+    }
+    _onRemovedMediaPlayout(mediaPlayout) {
+        this.onRemovedMediaPlayout?.(mediaPlayout, this.context);
+    }
+    _onMediaPlayoutUpdated(mediaPlayout) {
+        this.onMediaPlayoutUpdated?.(mediaPlayout, this.context);
+    }
+    _onMediaSourceAdded(mediaSource) {
+        this.onMediaSourceAdded?.(mediaSource, this.context);
+    }
+    _onMediaSourceRemoved(mediaSource) {
+        this.onMediaSourceRemoved?.(mediaSource, this.context);
+    }
+    _onMediaSourceUpdated(mediaSource) {
+        this.onMediaSourceUpdated?.(mediaSource, this.context);
+    }
+    _onClientIssue(observedClent, issue) {
+        this.onClientIssue?.(observedClent, issue, this.context);
+    }
+    _onClientMetadata(observedClient, metadata) {
+        this.onClientMetadata?.(observedClient, metadata, this.context);
+    }
+    _onClientExtensionStats(observedClient, extensionStats) {
+        this.onClientExtensionStats?.(observedClient, extensionStats, this.context);
+    }
+    _onClientJoined(observedClient) {
+        this.onClientJoined?.(observedClient, this.context);
+    }
+    _onClientLeft(observedClient) {
+        this.onClientLeft?.(observedClient, this.context);
+    }
+    _onUserMediaError(observedClient, error) {
+        this.onClientUserMediaError?.(observedClient, error, this.context);
+    }
+    _onUsingTurn(observedClient, usingTurn) {
+        this.onClientUsingTurn?.(observedClient, usingTurn, this.context);
+    }
+}
+exports.ObserverEventMonitor = ObserverEventMonitor;

package/lib/ObserverSummary.d.ts

@@ -0,0 +1,13 @@
+export type ObserverSummary = {
+    currentActiveCalls: number;
+    currentNumberOfClientsUsingTURN: number;
+    currentNumberOfClients: number;
+    totalAddedCall: number;
+    totalRemovedCall: number;
+    totalRttLt50Measurements: number;
+    totalRttLt150Measurements: number;
+    totalRttLt300Measurements: number;
+    totalRttGtOrEq300Measurements: number;
+    totalClientIssues: number;
+};
+//# sourceMappingURL=ObserverSummary.d.ts.map

package/lib/ObserverSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObserverSummary.d.ts","sourceRoot":"","sources":["../src/ObserverSummary.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC7B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,+BAA+B,EAAE,MAAM,CAAC;IACxC,sBAAsB,EAAE,MAAM,CAAC;IAE/B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IAEzB,wBAAwB,EAAE,MAAM,CAAC;IACjC,yBAAyB,EAAE,MAAM,CAAC;IAClC,yBAAyB,EAAE,MAAM,CAAC;IAClC,6BAA6B,EAAE,MAAM,CAAC;IAEtC,iBAAiB,EAAE,MAAM,CAAC;CAC1B,CAAA"}

package/lib/ObserverSummary.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/common/utils.d.ts

@@ -5,6 +5,7 @@ export type Writable<T> = T extends object ? {
 export declare function iteratorConverter<T>(generator: Generator<T, void, undefined>): IterableIterator<T>;
 export declare function asyncIteratorConverter<T>(generator: AsyncGenerator<T, void, undefined>): AsyncIterableIterator<T>;
 export declare function isValidUuid(str: string): boolean;
-export declare function getMedian(arr: number[]): number;
+export declare function getAverage(arr: number[], defaultAvgIfArrLengthIs0?: number): number;
+export declare function getMedian(arr: number[], copyArrayForSorting?: boolean): number;
 export declare function parseJsonAs<T>(json?: string): T | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/lib/common/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/common/utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/E,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,CAAC,CAAC;AAE9F,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CASlG;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,CASjH;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAIhD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,CAc/C;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAU3D"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/common/utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/E,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,CAAC,CAAC;AAE9F,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CASlG;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,CASjH;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAIhD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,wBAAwB,SAAI,GAAG,MAAM,CAI9E;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,mBAAmB,UAAO,GAAG,MAAM,CAkB3E;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAU3D"}

package/lib/common/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonAs = exports.getMedian = exports.isValidUuid = exports.asyncIteratorConverter = exports.iteratorConverter = void 0;
+exports.parseJsonAs = exports.getMedian = exports.getAverage = exports.isValidUuid = exports.asyncIteratorConverter = exports.iteratorConverter = void 0;
 function iteratorConverter(generator) {
     return {
         [Symbol.iterator]() {
@@ -28,9 +28,17 @@ function isValidUuid(str) {
     return regexp.test(str);
 }
 exports.isValidUuid = isValidUuid;
-function getMedian(arr) {
+function getAverage(arr, defaultAvgIfArrLengthIs0 = 0) {
+    if (arr.length === 0)
+        return defaultAvgIfArrLengthIs0;
+    return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+exports.getAverage = getAverage;
+function getMedian(arr, copyArrayForSorting = true) {
     // Sort the array in ascending order
-    const sortedArr = arr.slice().sort((a, b) => a - b);
+    const sortedArr = copyArrayForSorting
+        ? arr.slice().sort((a, b) => a - b)
+        : arr.sort((a, b) => a - b);
     // Calculate the middle index
     const mid = Math.floor(sortedArr.length / 2);
     // If the array length is odd, return the middle element

package/lib/index.d.ts

@@ -1,22 +1,28 @@
 export type { ObserverEvents } from './Observer';
 export { Observer } from './Observer';
 export { ObservedCall } from './ObservedCall';
-export { ObservedInboundTrack } from './ObservedInboundTrack';
-export { ObservedOutboundTrack } from './ObservedOutboundTrack';
+export { ObservedInboundTrack } from './webrtc/ObservedInboundTrack';
+export { ObservedOutboundTrack } from './webrtc/ObservedOutboundTrack';
 export { ObservedClient } from './ObservedClient';
-export { ObservedPeerConnection } from './ObservedPeerConnection';
-export { ObservedMediaSource } from './ObservedMediaSource';
-export { ObservedMediaPlayout } from './ObservedMediaPlayout';
-export { ObservedCodec } from './ObservedCodec';
-export { ObservedCertificate } from './ObservedCertificate';
-export { ObservedDataChannel } from './ObservedDataChannel';
-export { ObservedInboundRtp } from './ObservedInboundRtp';
-export { ObservedOutboundRtp } from './ObservedOutboundRtp';
-export { ObservedRemoteInboundRtp } from './ObservedRemoteInboundRtp';
-export { ObservedRemoteOutboundRtp } from './ObservedRemoteOutboundRtp';
-export { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
-export { ObservedIceCandidate } from './ObservedIceCandidate';
-export { ObservedIceTransport } from './ObservedIceTransport';
-export { ObservedPeerConnectionTransport } from './ObservedPeerConnectionTransport';
+export { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
+export { ObservedMediaSource } from './webrtc/ObservedMediaSource';
+export { ObservedMediaPlayout } from './webrtc/ObservedMediaPlayout';
+export { ObservedCodec } from './webrtc/ObservedCodec';
+export { ObservedCertificate } from './webrtc/ObservedCertificate';
+export { ObservedDataChannel } from './webrtc/ObservedDataChannel';
+export { ObservedInboundRtp } from './webrtc/ObservedInboundRtp';
+export { ObservedOutboundRtp } from './webrtc/ObservedOutboundRtp';
+export { ObservedRemoteInboundRtp } from './webrtc/ObservedRemoteInboundRtp';
+export { ObservedRemoteOutboundRtp } from './webrtc/ObservedRemoteOutboundRtp';
+export { ObservedIceCandidatePair } from './webrtc/ObservedIceCandidatePair';
+export { ObservedIceCandidate } from './webrtc/ObservedIceCandidate';
+export { ObservedIceTransport } from './webrtc/ObservedIceTransport';
+export { ObservedPeerConnectionTransport } from './webrtc/ObservedPeerConnectionTransport';
+export { ClientEventTypes } from './schema/ClientEventTypes';
+export { ClientMetaTypes } from './schema/ClientMetaTypes';
+export { ClientSample, ClientIssue, ClientEvent, ClientMetaData } from './schema/ClientSample';
+export { ScoreCalculator } from './scores/ScoreCalculator';
+export { ObservedClientEventMonitor } from './ObservedClientEventMonitor';
+export { ObserverEventMonitor } from './ObserverEventMonitor';
 export { Middleware } from './common/Middleware';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AAEpF,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAC3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC"}

package/lib/index.js

@@ -1,41 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservedPeerConnectionTransport = exports.ObservedIceTransport = exports.ObservedIceCandidate = exports.ObservedIceCandidatePair = exports.ObservedRemoteOutboundRtp = exports.ObservedRemoteInboundRtp = exports.ObservedOutboundRtp = exports.ObservedInboundRtp = exports.ObservedDataChannel = exports.ObservedCertificate = exports.ObservedCodec = exports.ObservedMediaPlayout = exports.ObservedMediaSource = exports.ObservedPeerConnection = exports.ObservedClient = exports.ObservedOutboundTrack = exports.ObservedInboundTrack = exports.ObservedCall = exports.Observer = void 0;
+exports.ObserverEventMonitor = exports.ObservedClientEventMonitor = exports.ClientMetaTypes = exports.ClientEventTypes = exports.ObservedPeerConnectionTransport = exports.ObservedIceTransport = exports.ObservedIceCandidate = exports.ObservedIceCandidatePair = exports.ObservedRemoteOutboundRtp = exports.ObservedRemoteInboundRtp = exports.ObservedOutboundRtp = exports.ObservedInboundRtp = exports.ObservedDataChannel = exports.ObservedCertificate = exports.ObservedCodec = exports.ObservedMediaPlayout = exports.ObservedMediaSource = exports.ObservedPeerConnection = exports.ObservedClient = exports.ObservedOutboundTrack = exports.ObservedInboundTrack = exports.ObservedCall = exports.Observer = void 0;
 var Observer_1 = require("./Observer");
 Object.defineProperty(exports, "Observer", { enumerable: true, get: function () { return Observer_1.Observer; } });
 var ObservedCall_1 = require("./ObservedCall");
 Object.defineProperty(exports, "ObservedCall", { enumerable: true, get: function () { return ObservedCall_1.ObservedCall; } });
-var ObservedInboundTrack_1 = require("./ObservedInboundTrack");
+var ObservedInboundTrack_1 = require("./webrtc/ObservedInboundTrack");
 Object.defineProperty(exports, "ObservedInboundTrack", { enumerable: true, get: function () { return ObservedInboundTrack_1.ObservedInboundTrack; } });
-var ObservedOutboundTrack_1 = require("./ObservedOutboundTrack");
+var ObservedOutboundTrack_1 = require("./webrtc/ObservedOutboundTrack");
 Object.defineProperty(exports, "ObservedOutboundTrack", { enumerable: true, get: function () { return ObservedOutboundTrack_1.ObservedOutboundTrack; } });
 var ObservedClient_1 = require("./ObservedClient");
 Object.defineProperty(exports, "ObservedClient", { enumerable: true, get: function () { return ObservedClient_1.ObservedClient; } });
-var ObservedPeerConnection_1 = require("./ObservedPeerConnection");
+var ObservedPeerConnection_1 = require("./webrtc/ObservedPeerConnection");
 Object.defineProperty(exports, "ObservedPeerConnection", { enumerable: true, get: function () { return ObservedPeerConnection_1.ObservedPeerConnection; } });
-var ObservedMediaSource_1 = require("./ObservedMediaSource");
+var ObservedMediaSource_1 = require("./webrtc/ObservedMediaSource");
 Object.defineProperty(exports, "ObservedMediaSource", { enumerable: true, get: function () { return ObservedMediaSource_1.ObservedMediaSource; } });
-var ObservedMediaPlayout_1 = require("./ObservedMediaPlayout");
+var ObservedMediaPlayout_1 = require("./webrtc/ObservedMediaPlayout");
 Object.defineProperty(exports, "ObservedMediaPlayout", { enumerable: true, get: function () { return ObservedMediaPlayout_1.ObservedMediaPlayout; } });
-var ObservedCodec_1 = require("./ObservedCodec");
+var ObservedCodec_1 = require("./webrtc/ObservedCodec");
 Object.defineProperty(exports, "ObservedCodec", { enumerable: true, get: function () { return ObservedCodec_1.ObservedCodec; } });
-var ObservedCertificate_1 = require("./ObservedCertificate");
+var ObservedCertificate_1 = require("./webrtc/ObservedCertificate");
 Object.defineProperty(exports, "ObservedCertificate", { enumerable: true, get: function () { return ObservedCertificate_1.ObservedCertificate; } });
-var ObservedDataChannel_1 = require("./ObservedDataChannel");
+var ObservedDataChannel_1 = require("./webrtc/ObservedDataChannel");
 Object.defineProperty(exports, "ObservedDataChannel", { enumerable: true, get: function () { return ObservedDataChannel_1.ObservedDataChannel; } });
-var ObservedInboundRtp_1 = require("./ObservedInboundRtp");
+var ObservedInboundRtp_1 = require("./webrtc/ObservedInboundRtp");
 Object.defineProperty(exports, "ObservedInboundRtp", { enumerable: true, get: function () { return ObservedInboundRtp_1.ObservedInboundRtp; } });
-var ObservedOutboundRtp_1 = require("./ObservedOutboundRtp");
+var ObservedOutboundRtp_1 = require("./webrtc/ObservedOutboundRtp");
 Object.defineProperty(exports, "ObservedOutboundRtp", { enumerable: true, get: function () { return ObservedOutboundRtp_1.ObservedOutboundRtp; } });
-var ObservedRemoteInboundRtp_1 = require("./ObservedRemoteInboundRtp");
+var ObservedRemoteInboundRtp_1 = require("./webrtc/ObservedRemoteInboundRtp");
 Object.defineProperty(exports, "ObservedRemoteInboundRtp", { enumerable: true, get: function () { return ObservedRemoteInboundRtp_1.ObservedRemoteInboundRtp; } });
-var ObservedRemoteOutboundRtp_1 = require("./ObservedRemoteOutboundRtp");
+var ObservedRemoteOutboundRtp_1 = require("./webrtc/ObservedRemoteOutboundRtp");
 Object.defineProperty(exports, "ObservedRemoteOutboundRtp", { enumerable: true, get: function () { return ObservedRemoteOutboundRtp_1.ObservedRemoteOutboundRtp; } });
-var ObservedIceCandidatePair_1 = require("./ObservedIceCandidatePair");
+var ObservedIceCandidatePair_1 = require("./webrtc/ObservedIceCandidatePair");
 Object.defineProperty(exports, "ObservedIceCandidatePair", { enumerable: true, get: function () { return ObservedIceCandidatePair_1.ObservedIceCandidatePair; } });
-var ObservedIceCandidate_1 = require("./ObservedIceCandidate");
+var ObservedIceCandidate_1 = require("./webrtc/ObservedIceCandidate");
 Object.defineProperty(exports, "ObservedIceCandidate", { enumerable: true, get: function () { return ObservedIceCandidate_1.ObservedIceCandidate; } });
-var ObservedIceTransport_1 = require("./ObservedIceTransport");
+var ObservedIceTransport_1 = require("./webrtc/ObservedIceTransport");
 Object.defineProperty(exports, "ObservedIceTransport", { enumerable: true, get: function () { return ObservedIceTransport_1.ObservedIceTransport; } });
-var ObservedPeerConnectionTransport_1 = require("./ObservedPeerConnectionTransport");
+var ObservedPeerConnectionTransport_1 = require("./webrtc/ObservedPeerConnectionTransport");
 Object.defineProperty(exports, "ObservedPeerConnectionTransport", { enumerable: true, get: function () { return ObservedPeerConnectionTransport_1.ObservedPeerConnectionTransport; } });
+var ClientEventTypes_1 = require("./schema/ClientEventTypes");
+Object.defineProperty(exports, "ClientEventTypes", { enumerable: true, get: function () { return ClientEventTypes_1.ClientEventTypes; } });
+var ClientMetaTypes_1 = require("./schema/ClientMetaTypes");
+Object.defineProperty(exports, "ClientMetaTypes", { enumerable: true, get: function () { return ClientMetaTypes_1.ClientMetaTypes; } });
+var ObservedClientEventMonitor_1 = require("./ObservedClientEventMonitor");
+Object.defineProperty(exports, "ObservedClientEventMonitor", { enumerable: true, get: function () { return ObservedClientEventMonitor_1.ObservedClientEventMonitor; } });
+var ObserverEventMonitor_1 = require("./ObserverEventMonitor");
+Object.defineProperty(exports, "ObserverEventMonitor", { enumerable: true, get: function () { return ObserverEventMonitor_1.ObserverEventMonitor; } });

package/lib/mediasoup/ObservedMediasoupRouter.d.ts

@@ -0,0 +1,7 @@
+import { Observer } from "../Observer";
+export declare class ObservedMediasoupRouter<T extends Record<string, unknown> = Record<string, unknown>> {
+    readonly parent: Observer;
+    readonly appData: T;
+    constructor(parent: Observer, appData?: T);
+}
+//# sourceMappingURL=ObservedMediasoupRouter.d.ts.map

package/lib/mediasoup/ObservedMediasoupRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservedMediasoupRouter.d.ts","sourceRoot":"","sources":["../../src/mediasoup/ObservedMediasoupRouter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;aAGxE,MAAM,EAAE,QAAQ;IAFpC,SAAgB,OAAO,EAAE,CAAC,CAAC;gBAEP,MAAM,EAAE,QAAQ,EAChC,OAAO,CAAC,EAAE,CAAC;CAIlB"}