@observertc/observer-js 0.42.8 → 1.0.0-5f150eb.0

package/lib/ObservedCallEventMonitor.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservedCallEventMonitor = void 0;
+class ObservedCallEventMonitor {
+    call;
+    context;
+    constructor(call, context) {
+        this.call = call;
+        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._onInboundRtpAdded = this._onInboundRtpAdded.bind(this);
+        this._onInboundRtpRemoved = this._onInboundRtpRemoved.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._onCallAdded(call);
+    }
+    // Public event handlers
+    onCallClosed;
+    onCallEmpty;
+    onCallNotEmpty;
+    onCallUpdated;
+    onClientAdded;
+    onClientClosed;
+    onClientRejoined;
+    onClientIssue;
+    onClientMetadata;
+    onClientExtensionStats;
+    onClientJoined;
+    onClientLeft;
+    onClientUserMediaError;
+    onClientUsingTurn;
+    onClientUpdated;
+    onClientEvent;
+    onPeerConnectionAdded;
+    onPeerConnectionRemoved;
+    onSelectedCandidatePairChanged;
+    onIceGatheringStateChange;
+    onIceConnectionStateChange;
+    onConnectionStateChange;
+    onCertificateAdded;
+    onCertificateRemoved;
+    onInboundTrackAdded;
+    onInboundTrackRemoved;
+    onOutboundTrackAdded;
+    onOutboundTrackRemoved;
+    onInboundRtpAdded;
+    onInboundRtpRemoved;
+    onOutboundRtpAdded;
+    onOutboundRtpRemoved;
+    onDataChannelAdded;
+    onDataChannelRemoved;
+    onAddedIceTransport;
+    onRemovedIceTransport;
+    onIceCandidateAdded;
+    onIceCandidateRemoved;
+    onAddedIceCandidatePair;
+    onRemovedIceCandidatePair;
+    onAddedMediaCodec;
+    onRemovedMediaCodec;
+    onAddedMediaPlayout;
+    onRemovedMediaPlayout;
+    onMediaSourceAdded;
+    onMediaSourceRemoved;
+    onTrackReport;
+    _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.onCallClosed?.(call, this.context);
+        });
+        call.on('newclient', this._onClientAdded);
+        call.on('empty', onCallEmpty);
+        call.on('not-empty', onCallNotEmpty);
+        call.on('update', onCallUpdated);
+    }
+    _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);
+        const onTrackReport = (trackReport) => this._onTrackReport(observedClient, trackReport);
+        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('update', onClientUpdated);
+            observedClient.off('clientEvent', onClientEvent);
+            observedClient.off('trackreport', onTrackReport);
+            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);
+        observedClient.on('trackreport', onTrackReport);
+        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('added-inbound-track', this._onInboundTrackAdded);
+            peerConnection.off('removed-inbound-track', this._onInboundTrackRemoved);
+            peerConnection.off('added-outbound-track', this._onOutboundTrackAdded);
+            peerConnection.off('removed-outbound-track', this._onOutboundTrackRemoved);
+            peerConnection.off('added-inbound-rtp', this._onInboundRtpAdded);
+            peerConnection.off('removed-inbound-rtp', this._onInboundRtpRemoved);
+            peerConnection.off('added-outbound-rtp', this._onOutboundRtpAdded);
+            peerConnection.off('removed-outbound-rtp', this._onOutboundRtpRemoved);
+            peerConnection.off('added-data-channel', this._onDataChannelAdded);
+            peerConnection.off('removed-data-channel', this._onDataChannelRemoved);
+            peerConnection.off('added-ice-transport', this._onAddedIceTransport);
+            peerConnection.off('removed-ice-transport', this._onRemovedIceTransport);
+            peerConnection.off('added-ice-candidate', this._onIceCandidateAdded);
+            peerConnection.off('removed-ice-candidate', this._onIceCandidateRemoved);
+            peerConnection.off('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+            peerConnection.off('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+            peerConnection.off('added-codec', this._onAddedMediaCodec);
+            peerConnection.off('removed-codec', this._onRemovedMediaCodec);
+            peerConnection.off('added-media-playout', this._onAddedMediaPlayout);
+            peerConnection.off('removed-media-playout', this._onRemovedMediaPlayout);
+            peerConnection.off('added-media-source', this._onMediaSourceAdded);
+            peerConnection.off('removed-media-source', this._onMediaSourceRemoved);
+            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('added-inbound-track', this._onInboundTrackAdded);
+        peerConnection.on('removed-inbound-track', this._onInboundTrackRemoved);
+        peerConnection.on('added-outbound-track', this._onOutboundTrackAdded);
+        peerConnection.on('removed-outbound-track', this._onOutboundTrackRemoved);
+        peerConnection.on('added-inbound-rtp', this._onInboundRtpAdded);
+        peerConnection.on('removed-inbound-rtp', this._onInboundRtpRemoved);
+        peerConnection.on('added-outbound-rtp', this._onOutboundRtpAdded);
+        peerConnection.on('removed-outbound-rtp', this._onOutboundRtpRemoved);
+        peerConnection.on('added-data-channel', this._onDataChannelAdded);
+        peerConnection.on('removed-data-channel', this._onDataChannelRemoved);
+        peerConnection.on('added-ice-transport', this._onAddedIceTransport);
+        peerConnection.on('removed-ice-transport', this._onRemovedIceTransport);
+        peerConnection.on('added-ice-candidate', this._onIceCandidateAdded);
+        peerConnection.on('removed-ice-candidate', this._onIceCandidateRemoved);
+        peerConnection.on('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+        peerConnection.on('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+        peerConnection.on('added-codec', this._onAddedMediaCodec);
+        peerConnection.on('removed-codec', this._onRemovedMediaCodec);
+        peerConnection.on('added-media-playout', this._onAddedMediaPlayout);
+        peerConnection.on('removed-media-playout', this._onRemovedMediaPlayout);
+        peerConnection.on('added-media-source', this._onMediaSourceAdded);
+        peerConnection.on('removed-media-source', this._onMediaSourceRemoved);
+        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);
+    }
+    _onInboundTrackAdded(inboundTrack) {
+        this.onInboundTrackAdded?.(inboundTrack, this.context);
+    }
+    _onInboundTrackRemoved(inboundTrack) {
+        this.onInboundTrackRemoved?.(inboundTrack, this.context);
+    }
+    _onOutboundTrackAdded(outboundTrack) {
+        this.onOutboundTrackAdded?.(outboundTrack, this.context);
+    }
+    _onOutboundTrackRemoved(outboundTrack) {
+        this.onOutboundTrackRemoved?.(outboundTrack, this.context);
+    }
+    _onInboundRtpAdded(inboundRtp) {
+        this.onInboundRtpAdded?.(inboundRtp, this.context);
+    }
+    _onInboundRtpRemoved(inboundRtp) {
+        this.onInboundRtpRemoved?.(inboundRtp, this.context);
+    }
+    _onOutboundRtpAdded(outboundRtp) {
+        this.onOutboundRtpAdded?.(outboundRtp, this.context);
+    }
+    _onOutboundRtpRemoved(outboundRtp) {
+        this.onOutboundRtpRemoved?.(outboundRtp, this.context);
+    }
+    _onDataChannelAdded(dataChannel) {
+        this.onDataChannelAdded?.(dataChannel, this.context);
+    }
+    _onDataChannelRemoved(dataChannel) {
+        this.onDataChannelRemoved?.(dataChannel, this.context);
+    }
+    _onAddedIceTransport(iceTransport) {
+        this.onAddedIceTransport?.(iceTransport, this.context);
+    }
+    _onRemovedIceTransport(iceTransport) {
+        this.onRemovedIceTransport?.(iceTransport, this.context);
+    }
+    _onIceCandidateAdded(iceCandidate) {
+        this.onIceCandidateAdded?.(iceCandidate, this.context);
+    }
+    _onIceCandidateRemoved(iceCandidate) {
+        this.onIceCandidateRemoved?.(iceCandidate, this.context);
+    }
+    _onAddedIceCandidatePair(candidatePair) {
+        this.onAddedIceCandidatePair?.(candidatePair, this.context);
+    }
+    _onRemovedIceCandidatePair(candidatePair) {
+        this.onRemovedIceCandidatePair?.(candidatePair, this.context);
+    }
+    _onAddedMediaCodec(codec) {
+        this.onAddedMediaCodec?.(codec, this.context);
+    }
+    _onRemovedMediaCodec(codec) {
+        this.onRemovedMediaCodec?.(codec, this.context);
+    }
+    _onAddedMediaPlayout(mediaPlayout) {
+        this.onAddedMediaPlayout?.(mediaPlayout, this.context);
+    }
+    _onRemovedMediaPlayout(mediaPlayout) {
+        this.onRemovedMediaPlayout?.(mediaPlayout, this.context);
+    }
+    _onMediaSourceAdded(mediaSource) {
+        this.onMediaSourceAdded?.(mediaSource, this.context);
+    }
+    _onMediaSourceRemoved(mediaSource) {
+        this.onMediaSourceRemoved?.(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);
+    }
+    _onTrackReport(client, trackReport) {
+        this.onTrackReport?.(trackReport, this.context);
+    }
+}
+exports.ObservedCallEventMonitor = ObservedCallEventMonitor;

package/lib/ObservedCallSummary.d.ts

@@ -0,0 +1,18 @@
+export type ObservedCallSummary = {
+    currentActiveClients: number;
+    totalAddedClients: number;
+    totalRemovedClients: number;
+    totalClientsSentBytes: number;
+    totalClientsReceivedBytes: number;
+    totalClientsReceivedAudioBytes: number;
+    totalClientsReceivedVideoBytes: number;
+    totalClientsSentAudioBytes: number;
+    totalClientsSentVideoBytes: number;
+    totalRttLt50Measurements: number;
+    totalRttLt150Measurements: number;
+    totalRttLt300Measurements: number;
+    totalRttGtOrEq300Measurements: number;
+    numberOfIssues: number;
+    numberOfClientsUsedTurn: number;
+};
+//# sourceMappingURL=ObservedCallSummary.d.ts.map

package/lib/ObservedCallSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservedCallSummary.d.ts","sourceRoot":"","sources":["../src/ObservedCallSummary.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG;IACjC,oBAAoB,EAAE,MAAM,CAAC;IAE7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAE5B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,yBAAyB,EAAE,MAAM,CAAC;IAClC,8BAA8B,EAAE,MAAM,CAAC;IACvC,8BAA8B,EAAE,MAAM,CAAC;IACvC,0BAA0B,EAAE,MAAM,CAAC;IACnC,0BAA0B,EAAE,MAAM,CAAC;IAEnC,wBAAwB,EAAE,MAAM,CAAC;IACjC,yBAAyB,EAAE,MAAM,CAAC;IAClC,yBAAyB,EAAE,MAAM,CAAC;IAClC,6BAA6B,EAAE,MAAM,CAAC;IAEtC,cAAc,EAAE,MAAM,CAAC;IAEvB,uBAAuB,EAAE,MAAM,CAAC;CAChC,CAAA"}

package/lib/ObservedCertificate.d.ts

@@ -0,0 +1,19 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { CertificateStats } from './schema/ClientSample';
+export 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;
+}
+//# sourceMappingURL=ObservedCertificate.d.ts.map

package/lib/ObservedCertificate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservedCertificate.d.ts","sourceRoot":"","sources":["../src/ObservedCertificate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,mBAAoB,YAAW,gBAAgB;IAYnD,SAAS,EAAE,MAAM;IACjB,EAAE,EAAE,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAb1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEzC,OAAO,CAAC,QAAQ,CAAS;IAEzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAG9B,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,EACA,eAAe,EAAE,sBAAsB;IAGzD,IAAW,OAAO,YAMjB;IAEM,iBAAiB;IAIjB,MAAM,CAAC,KAAK,EAAE,gBAAgB;CAUrC"}

package/lib/ObservedCertificate.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservedCertificate = void 0;
+class ObservedCertificate {
+    timestamp;
+    id;
+    _peerConnection;
+    appData;
+    _visited = false;
+    fingerprint;
+    fingerprintAlgorithm;
+    base64Certificate;
+    issuerCertificateId;
+    attachments;
+    constructor(timestamp, id, _peerConnection) {
+        this.timestamp = timestamp;
+        this.id = id;
+        this._peerConnection = _peerConnection;
+    }
+    get visited() {
+        const visited = this._visited;
+        this._visited = false;
+        return visited;
+    }
+    getPeerConnection() {
+        return this._peerConnection;
+    }
+    update(stats) {
+        this._visited = true;
+        this.timestamp = stats.timestamp;
+        this.fingerprint = stats.fingerprint;
+        this.fingerprintAlgorithm = stats.fingerprintAlgorithm;
+        this.base64Certificate = stats.base64Certificate;
+        this.issuerCertificateId = stats.issuerCertificateId;
+        this.attachments = stats.attachments;
+    }
+}
+exports.ObservedCertificate = ObservedCertificate;

package/lib/ObservedClient.d.ts

@@ -1,182 +1,115 @@
 /// <reference types="node" />
-import { Browser, ClientSample, Engine, IceLocalCandidate, IceRemoteCandidate, MediaCodecStats, MediaDevice, OperationSystem, Platform } from '@observertc/sample-schemas-js';
-import { ObservedCall } from './ObservedCall';
 import { EventEmitter } from 'events';
 import { ObservedPeerConnection } from './ObservedPeerConnection';
-import { PartialBy } from './common/utils';
-import { ObservedSfu } from './ObservedSfu';
-import { ClientIssue } from './monitors/CallSummary';
-import { CallEventReport } from '@observertc/report-schemas-js';
-import { CalculatedScore } from './common/CalculatedScore';
-export type ObservedClientModel = {
+import { ClientEvent, ClientMetaData, ClientSample, ClientIssue, ExtensionStat } from './schema/ClientSample';
+import * as MetaData from './schema/ClientMetaTypes';
+import { ObservedCall } from './ObservedCall';
+import { CalculatedScore } from './scores/CalculatedScore';
+import { Detectors } from './detectors/Detectors';
+import { ClientReport, TrackReport } from './Reports';
+export type ObservedClientSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
     clientId: string;
-    mediaUnitId: string;
-    userId?: string;
-    marker?: string;
-    operationSystem?: OperationSystem;
-    engine?: Engine;
-    platform?: Platform;
-    browser?: Browser;
-    coordinates?: {
-        latitude: number;
-        longitude: number;
-    };
+    appData?: AppData;
+    closeClientIfIdleForMs?: number;
 };
 export type ObservedClientEvents = {
-    update: [
-        {
-            sample: ClientSample;
-            elapsedTimeInMs: number;
-        }
-    ];
+    update: [sample: ClientSample, elapsedTimeInMs: number];
     close: [];
     joined: [];
-    left: [];
-    newpeerconnection: [ObservedPeerConnection];
-    iceconnectionstatechange: [
-        {
-            peerConnection: ObservedPeerConnection;
-            state: string;
-        }
-    ];
-    icegatheringstatechange: [
-        {
-            peerConnection: ObservedPeerConnection;
-            state: string;
-        }
-    ];
-    connectionstatechange: [
-        {
-            peerConnection: ObservedPeerConnection;
-            state: string;
-        }
-    ];
-    selectedcandidatepair: [
-        {
-            peerConnection: ObservedPeerConnection;
-            localCandidate: IceLocalCandidate;
-            remoteCandidate: IceRemoteCandidate;
-        }
-    ];
     issue: [ClientIssue];
+    metaData: [ClientMetaData];
+    rejoined: [timestamp: number];
+    left: [];
     usingturn: [boolean];
     usermediaerror: [string];
-    rejoined: [
-        {
-            lastJoined: number;
-        }
-    ];
-    score: [CalculatedScore];
+    extensionStats: [ExtensionStat];
+    clientEvent: [ClientEvent];
+    newpeerconnection: [ObservedPeerConnection];
+    trackreport: [TrackReport];
 };
-export declare interface ObservedClient<AppData extends Record<string, unknown> = Record<string, unknown>> {
+export 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;
-    readonly appData: AppData;
 }
-type PendingPeerConnectionTimestamp = {
-    type: 'opened' | 'closed';
-    peerConnectionId: string;
-    timestamp: number;
-};
-type PendingMediaTrackTimestamp = {
-    type: 'added' | 'removed';
-    peerConnectionId: string;
-    mediaTrackId: string;
-    timestamp: number;
-};
 export declare class ObservedClient<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
-    private readonly _model;
     readonly call: ObservedCall;
-    readonly appData: AppData;
-    readonly created: number;
+    readonly detectors: Detectors;
+    readonly clientId: string;
+    readonly observedPeerConnections: Map<string, ObservedPeerConnection>;
+    readonly calculatedScore: CalculatedScore;
+    readonly settings: Pick<ObservedClientSettings, 'closeClientIfIdleForMs'>;
+    appData: AppData;
+    attachments?: Record<string, unknown>;
     updated: number;
-    sfuId?: string;
-    private readonly _peerConnections;
-    private _closed;
-    private _acceptedSamples;
-    private _timeZoneOffsetInHours?;
-    private _joined?;
-    private _left?;
-    lastStatsTimestamp?: number;
-    score?: CalculatedScore;
+    acceptedSamples: number;
+    closed: boolean;
+    joinedAt?: number;
+    leftAt?: number;
+    closedAt?: number;
+    lastSampleTimestamp?: number;
+    operationSystem?: MetaData.OperationSystem;
+    engine?: MetaData.Engine;
+    platform?: MetaData.Platform;
+    browser?: MetaData.Browser;
+    mediaConstraints: string[];
     usingTURN: boolean;
+    usingTCP: boolean;
     availableOutgoingBitrate: number;
     availableIncomingBitrate: number;
-    totalInboundPacketsLost: number;
-    totalInboundPacketsReceived: number;
-    totalOutboundPacketsSent: number;
-    totalDataChannelBytesSent: number;
-    totalDataChannelBytesReceived: number;
-    totalSentBytes: number;
-    totalReceivedBytes: number;
-    totalReceivedAudioBytes: number;
-    totalReceivedVideoBytes: number;
-    totalSentAudioBytes: number;
-    totalSentVideoBytes: number;
     deltaReceivedAudioBytes: number;
     deltaReceivedVideoBytes: number;
     deltaSentAudioBytes: number;
     deltaSentVideoBytes: number;
     deltaDataChannelBytesSent: number;
     deltaDataChannelBytesReceived: number;
+    deltaDataChannelMessagesSent: number;
+    deltaDataChannelMessagesReceived: number;
     deltaInboundPacketsLost: number;
     deltaInboundPacketsReceived: number;
     deltaOutboundPacketsSent: number;
-    avgRttInMs?: number;
-    outboundAudioBitrate?: number;
-    outboundVideoBitrate?: number;
-    inboundAudioBitrate?: number;
-    inboundVideoBitrate?: number;
-    mediaConstraints: string[];
-    readonly mediaDevices: MediaDevice[];
-    readonly mediaCodecs: MediaCodecStats[];
-    readonly userMediaErrors: string[];
+    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 report: ClientReport;
+    readonly mediaDevices: MetaData.MediaDeviceInfo[];
     issues: ClientIssue[];
-    ωpendingPeerConnectionTimestamps: PendingPeerConnectionTimestamp[];
-    ωpendingMediaTrackTimestamps: PendingMediaTrackTimestamp[];
-    constructor(_model: ObservedClientModel, call: ObservedCall, appData: AppData);
-    getSfu<T extends Record<string, unknown> = Record<string, unknown>>(): ObservedSfu<T> | undefined;
-    get joined(): number | undefined;
-    set joined(value: number | undefined);
-    get left(): number | undefined;
-    set left(value: number | undefined);
-    get sfu(): ObservedSfu | undefined;
-    get coordinates(): {
-        latitude: number;
-        longitude: number;
-    } | undefined;
-    set coordinates(value: {
-        latitude: number;
-        longitude: number;
-    } | undefined);
-    get clientId(): string;
-    get roomId(): string;
-    get serviceId(): string;
-    get callId(): string;
-    get mediaUnitId(): string;
-    get reports(): import("./ReportsCollector").ReportsCollector;
-    get userId(): string | undefined;
-    set userId(userId: string | undefined);
-    get timeZoneOffsetInHours(): number | undefined;
-    get marker(): string | undefined;
-    get browser(): Browser | undefined;
-    get engine(): Engine | undefined;
-    get operationSystem(): OperationSystem | undefined;
-    get platform(): Platform | undefined;
-    get acceptedSamples(): number;
-    get closed(): boolean;
-    get peerConnections(): ReadonlyMap<string, ObservedPeerConnection>;
+    private _injections;
+    private closeTimer?;
+    constructor(settings: ObservedClientSettings<AppData>, call: ObservedCall);
+    get numberOfPeerConnections(): number;
+    get score(): number | undefined;
     close(): void;
-    addEventReport(params: PartialBy<Omit<CallEventReport, 'serviceId' | 'roomId' | 'callId' | 'clientId' | 'userId' | 'marker' | 'attachments'>, 'timestamp'> & {
-        attachments?: Record<string, unknown>;
-    }): void;
-    addExtensionStatsReport(extensionType: string, payload?: Record<string, unknown>): void;
-    addIssue(issue: ClientIssue): void;
     accept(sample: ClientSample): void;
-    private _addAndEmitIssue;
-    private _createPeerConnection;
+    private _processClientEvent;
+    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 _updatePeerConnection;
+    private _mergeInjections;
 }
-export {};
 //# sourceMappingURL=ObservedClient.d.ts.map