@livedigital/client 2.26.0-stop-streams.1 → 2.27.0

package/dist/types/common.d.ts

@@ -305,7 +305,7 @@ export declare type UpdatePeerAppDataPayload = {
     appData: Record<string, unknown>;
 };
 export declare type CreateTracksPayload = {
-    stream: MediaStream;
+    mediaStreamTracks: MediaStreamTrack[];
     constraints: MediaStreamConstraints;
 };
 export declare type TrackPublishParams = {

package/dist/types/engine.d.ts

@@ -1,3 +1,4 @@
+import WebRTCIssueDetector, { IssueDetectorResult, NetworkScores } from 'webrtc-issue-detector';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from '../engine/system';
 import Media from '../engine/media';
@@ -5,9 +6,7 @@ import Network from '../engine/network';
 import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
-import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { IssueDetectorResult, NetworkScores } from '../engine/wid/types';
 import { Logger, LogLevel } from './common';
 export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
 export declare type NetworkScoresUpdatedHandler = (networks: NetworkScores) => void;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.26.0-stop-streams.1",
+  "version": "2.27.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -47,7 +47,8 @@
     "mediasoup-client": "^3.6.50",
     "qs": "^6.9.6",
     "serialize-error": "^7.0.1",
-    "socket.io-client": "^4.3.0"
+    "socket.io-client": "^4.3.0",
+    "webrtc-issue-detector": "^1.3.1"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^19.0.0",

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -1,10 +1,24 @@
+import WebRTCIssueDetector, {
+  QualityLimitationsIssueDetector,
+  FramesDroppedIssueDetector,
+  FramesEncodedSentIssueDetector,
+  InboundNetworkIssueDetector,
+  OutboundNetworkIssueDetector,
+  NetworkMediaSyncIssueDetector,
+  AvailableOutgoingBitrateIssueDetector,
+  VideoCodecMismatchDetector,
+  CompositeRTCStatsParser,
+  WebRTCIssueEmitter,
+  NetworkScoresCalculator,
+  PeriodicWebRTCStatsReporter,
+  RTCStatsParser,
+} from 'webrtc-issue-detector';
 import Network from './network';
 import System from './system';
 import Media from './media';
 import ChannelEventHandler from './handlers/ChannelEventHandler';
 import Engine from './index';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
-import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import {
   CreateIssueDetectorParams,
   CreateMediaParams,
@@ -14,19 +28,6 @@ import {
 } from '../types/engine';
 import SocketIO from './network/Socket';
 import LoadBalancerApiClient from './network/LoadBalancerClient';
-import NetworkScoresCalculator from './wid/lib/NetworkScoresCalculator';
-import QualityLimitationsIssueDetector from './wid/detectors/QualityLimitationsIssueDetector';
-import FramesDroppedIssueDetector from './wid/detectors/FramesDroppedIssueDetector';
-import FramesEncodedSentIssueDetector from './wid/detectors/FramesEncodedSentIssueDetector';
-import InboundNetworkIssueDetector from './wid/detectors/InboundNetworkIssueDetector';
-import OutboundNetworkIssueDetector from './wid/detectors/OutboundNetworkIssueDetector';
-import NetworkMediaSyncIssueDetector from './wid/detectors/NetworkMediaSyncIssueDetector';
-import AvailableOutgoingBitrateIssueDetector from './wid/detectors/AvailableOutgoingBitrateIssueDetector';
-import VideoCodecMismatchDetector from './wid/detectors/VideoCodecMismatchDetector';
-import CompositeRTCStatsParser from './wid/lib/parser/CompositeRTCStatsParser';
-import RTCStatsParser from './wid/lib/parser/RTCStatsParser';
-import PeriodicWebRTCStatsReporter from './wid/lib/PeriodicWebRTCStatsReporter';
-import { WebRTCIssueEmitter } from './wid/WebRTCIssueEmitter';
 
 /* eslint-disable class-methods-use-this */
 class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {

package/src/engine/index.ts

@@ -1,4 +1,5 @@
 import { RtpCapabilities } from 'mediasoup-client/lib/RtpParameters';
+import WebRTCIssueDetector from 'webrtc-issue-detector';
 import {
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
@@ -26,7 +27,6 @@ import {
 import { GetNodeRequest } from '../types/network';
 import VideoTrack from './media/tracks/VideoTrack';
 import PeerTrack from './media/tracks/PeerTrack';
-import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import { retryAsync } from '../helpers/retry';
 import { EngineDependenciesFactory, IssuesHandler, NetworkScoresUpdatedHandler } from '../types/engine';
 import { LogLevels } from '../constants/common';
@@ -161,7 +161,7 @@ class Engine {
       const { state, code } = evt;
       this.clientEventEmitter.emit(state, { code });
 
-      if (state === SocketIOEvents.Reconnecting) {
+      if (state === SocketIOEvents.Reconnected) {
         this.network.socket.disconnect();
         this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
       }

package/src/engine/media/index.ts

@@ -15,7 +15,7 @@ import { SCREEN_SHARING_SIMULCAST_ENCODINGS, WEBCAM_SIMULCAST_ENCODINGS } from '
 import { CreateMediaParams } from '../../types/engine';
 import Engine from '../index';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import TrackMediaStreamManager from './tracks/TrackMediaStreamManager';
+import MediaStreamTrackManager from './tracks/MediaStreamTrackManager';
 
 class Media {
   public isDeviceLoaded = false;
@@ -32,6 +32,8 @@ class Media {
 
   readonly #clientEventEmitter: EnhancedEventEmitter;
 
+  readonly #mediaStreamTrackManager: MediaStreamTrackManager;
+
   constructor(params: CreateMediaParams) {
     this.#logLevel = params.logLevel;
     this.#logger = new Logger({
@@ -40,6 +42,7 @@ class Media {
     });
     this.#engine = params.engine;
     this.#clientEventEmitter = params.clientEventEmitter;
+    this.#mediaStreamTrackManager = new MediaStreamTrackManager(params.logLevel);
   }
 
   get mediasoupDevice(): Device {
@@ -67,21 +70,20 @@ class Media {
     return codecs.find((c) => c.mimeType.toLowerCase() === `${track.kind}/${track.getPreferredCodec()}`);
   }
 
-  private createTracks({ constraints, stream }: CreateTracksPayload): Track[] {
-    const mediaStreamTracks = stream.getTracks();
+  private createTracks({ constraints, mediaStreamTracks }: CreateTracksPayload): Track[] {
     return mediaStreamTracks.map((mediaStreamTrack) => {
       const params = {
         mediaStreamTrack,
         logLevel: this.#logLevel,
         engine: this.#engine,
         clientEventEmitter: this.#clientEventEmitter,
-        mediaStreamManager: new TrackMediaStreamManager(constraints),
+        constraints,
+        mediaStreamTrackManager: this.#mediaStreamTrackManager,
       };
 
       const track = mediaStreamTrack.kind === 'audio' ? new AudioTrack(params) : new VideoTrack(params);
       this.tracks.set(track.id, track);
       this.#logger.debug('createTrack() track created', {
-        streamId: stream.id,
         trackId: track.id,
         kind: track.kind,
       });
@@ -91,14 +93,13 @@ class Media {
   }
 
   async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
-    const stream = await navigator.mediaDevices.getUserMedia(constraints);
-    this.#logger.debug('createUserMediaTrack() stream created', { streamId: stream.id });
-    return this.createTracks({ stream, constraints });
+    const mediaStreamTracks = await this.#mediaStreamTrackManager.createUserMediaTracks(constraints);
+    return this.createTracks({ constraints, mediaStreamTracks });
   }
 
   async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
-    const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
-    return this.createTracks({ stream, constraints });
+    const mediaStreamTracks = await this.#mediaStreamTrackManager.createDisplayMediaTracks(constraints);
+    return this.createTracks({ constraints, mediaStreamTracks });
   }
 
   deleteTrack(track: Track) {

package/src/engine/media/tracks/BaseTrack.ts

@@ -16,15 +16,15 @@ import { PRODUCER_CHECK_STATE_TIMEOUT } from '../../../constants/common';
 import { CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, MEDIASOUP_EVENTS } from '../../../constants/events';
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
 import filterStatsCodecs from '../../../helpers/filterStatsCodecs';
-import Timeout = NodeJS.Timeout;
-import TrackMediaStreamManager from './TrackMediaStreamManager';
+import MediaStreamTrackManager from './MediaStreamTrackManager';
 
 export type BaseTrackConstructorParams = {
   mediaStreamTrack: MediaStreamTrack,
   logLevel: LogLevel,
   engine: Engine,
   clientEventEmitter: EnhancedEventEmitter,
-  mediaStreamManager: TrackMediaStreamManager,
+  constraints: MediaStreamConstraints;
+  mediaStreamTrackManager: MediaStreamTrackManager;
 };
 
 class BaseTrack {
@@ -42,7 +42,7 @@ class BaseTrack {
 
   #selfConsumer?: PeerConsumer;
 
-  #checkStateTimeout?: Timeout;
+  #checkStateTimeout?: NodeJS.Timeout;
 
   #producerRestarted = false;
 
@@ -50,16 +50,19 @@ class BaseTrack {
 
   #closed = false;
 
-  readonly #mediaStreamManager: TrackMediaStreamManager;
+  readonly #constraints: MediaStreamConstraints;
+
+  readonly #mediaStreamTrackManager: MediaStreamTrackManager;
 
   constructor(params: BaseTrackConstructorParams) {
     const {
-      mediaStreamTrack, logLevel, engine, clientEventEmitter, mediaStreamManager,
+      mediaStreamTrack, logLevel, engine, clientEventEmitter, constraints, mediaStreamTrackManager,
     } = params;
     this.#mediaStreamTrack = mediaStreamTrack;
     this.#engine = engine;
     this.#clientEventEmitter = clientEventEmitter;
-    this.#mediaStreamManager = mediaStreamManager;
+    this.#constraints = constraints;
+    this.#mediaStreamTrackManager = mediaStreamTrackManager;
     this.logger = new Logger({
       namespace: 'Track',
       logLevel,
@@ -102,7 +105,6 @@ class BaseTrack {
 
   setLabel(label: TrackLabel): void {
     this.label = label;
-    this.#mediaStreamManager.setLabel(label);
   }
 
   setEncoderConfig(encoderConfig: EncoderConfig): void {
@@ -389,7 +391,10 @@ class BaseTrack {
     }
 
     try {
-      const track = await this.#mediaStreamManager.getMediaStreamTrack();
+      const track = await this.#mediaStreamTrackManager.createMediaStreamTrack({
+        label: this.label,
+        constraints: this.#constraints,
+      });
       this.#mediaStreamTrack = track;
       await this.producer.replaceTrack({ track });
       await this.resumeRemoteProducer(this.producer.id);

package/src/engine/media/tracks/MediaStreamTrackManager.ts

@@ -0,0 +1,46 @@
+import { LogLevel, TrackLabel } from '../../../types/common';
+import Logger from '../../Logger';
+
+export type GetMediaStreamTrackParams = {
+  label: TrackLabel;
+  constraints: MediaStreamConstraints;
+};
+
+class MediaStreamTrackManager {
+  readonly #logger: Logger;
+
+  constructor(logLevel: LogLevel) {
+    this.#logger = new Logger({
+      namespace: 'MediaStreamTrackManager',
+      logLevel,
+    });
+  }
+
+  async createMediaStreamTrack({ label, constraints }: GetMediaStreamTrackParams): Promise<MediaStreamTrack> {
+    if (MediaStreamTrackManager.isDisplayMedia(label)) {
+      const [track] = await this.createDisplayMediaTracks(constraints);
+      return track;
+    }
+
+    const [track] = await this.createUserMediaTracks(constraints);
+    return track;
+  }
+
+  private static isDisplayMedia(label: TrackLabel): boolean {
+    return [TrackLabel.ScreenVideo, TrackLabel.ScreenAudio].includes(label);
+  }
+
+  async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<MediaStreamTrack[]> {
+    const stream = await navigator.mediaDevices.getUserMedia(constraints);
+    this.#logger.debug('createUserMediaTracks() stream created', { streamId: stream.id });
+    return stream.getTracks();
+  }
+
+  async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<MediaStreamTrack[]> {
+    const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
+    this.#logger.debug('getDisplayMediaTracks() stream created', { streamId: stream.id });
+    return stream.getTracks();
+  }
+}
+
+export default MediaStreamTrackManager;

package/src/types/common.ts

@@ -351,7 +351,7 @@ export type UpdatePeerAppDataPayload = {
 };
 
 export type CreateTracksPayload = {
-  stream: MediaStream,
+  mediaStreamTracks: MediaStreamTrack[],
   constraints: MediaStreamConstraints,
 };
 

package/src/types/engine.ts

@@ -1,3 +1,4 @@
+import WebRTCIssueDetector, { IssueDetectorResult, NetworkScores } from 'webrtc-issue-detector';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from '../engine/system';
 import Media from '../engine/media';
@@ -5,9 +6,7 @@ import Network from '../engine/network';
 import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
-import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { IssueDetectorResult, NetworkScores } from '../engine/wid/types';
 import { Logger, LogLevel } from './common';
 
 export type IssuesHandler = (issues: IssueDetectorResult) => void;

package/dist/engine/media/tracks/TrackMediaStreamManager.d.ts

@@ -1,11 +0,0 @@
-import { TrackLabel } from '../../../types/common';
-declare class TrackMediaStreamManager {
-    #private;
-    constructor(constraints: MediaStreamConstraints);
-    setLabel(label: TrackLabel): void;
-    getMediaStreamTrack(): Promise<MediaStreamTrack>;
-    private get isDisplayMedia();
-    private getUserMediaTrack;
-    private getDisplayMediaTrack;
-}
-export default TrackMediaStreamManager;

package/dist/engine/wid/WebRTCIssueDetector.d.ts

@@ -1,20 +0,0 @@
-import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
-import { WebRTCIssueDetectorConstructorParams } from './types';
-declare class WebRTCIssueDetector {
-    #private;
-    readonly eventEmitter: WebRTCIssueEmitter;
-    private readonly detectors;
-    private readonly networkScoresCalculator;
-    private readonly statsReporter;
-    private readonly compositeStatsParser;
-    private readonly logger;
-    constructor(params: WebRTCIssueDetectorConstructorParams);
-    watchNewPeerConnections(): void;
-    stopWatchingNewPeerConnections(): void;
-    handleNewPeerConnection(pc: RTCPeerConnection): void;
-    private emitIssues;
-    private detectIssues;
-    private calculateNetworkScores;
-    private wrapRTCPeerConnection;
-}
-export default WebRTCIssueDetector;

package/dist/engine/wid/WebRTCIssueEmitter.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { EventType, EventPayload, IssueDetectorResult, NetworkScores } from './types';
-export declare interface WebRTCIssueEmitter {
-    on(event: EventType.Issue, listener: (payload: IssueDetectorResult) => void): this;
-    on(event: EventType.NetworkScoresUpdated, listener: (payload: NetworkScores) => void): this;
-    emit(event: EventType.Issue, payload: EventPayload): boolean;
-    emit(event: EventType.NetworkScoresUpdated, payload: NetworkScores): boolean;
-}
-export declare class WebRTCIssueEmitter extends EventEmitter {
-}

package/dist/engine/wid/detectors/AvailableOutgoingBitrateIssueDetector.d.ts

@@ -1,6 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class AvailableOutgoingBitrateIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-}
-export default AvailableOutgoingBitrateIssueDetector;

package/dist/engine/wid/detectors/FramesDroppedIssueDetector.d.ts

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class FramesDroppedIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default FramesDroppedIssueDetector;

package/dist/engine/wid/detectors/FramesEncodedSentIssueDetector.d.ts

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class FramesEncodedSentIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default FramesEncodedSentIssueDetector;

package/dist/engine/wid/detectors/InboundNetworkIssueDetector.d.ts

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class InboundNetworkIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default InboundNetworkIssueDetector;

package/dist/engine/wid/detectors/NetworkMediaSyncIssueDetector.d.ts

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class NetworkMediaSyncIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default NetworkMediaSyncIssueDetector;

package/dist/engine/wid/detectors/OutboundNetworkIssueDetector.d.ts

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class OutboundNetworkIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default OutboundNetworkIssueDetector;

package/dist/engine/wid/detectors/QualityLimitationsIssueDetector.d.ts

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class QualityLimitationsIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default QualityLimitationsIssueDetector;

package/dist/engine/wid/detectors/VideoCodecMismatchDetector.d.ts

@@ -1,10 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class VideoCodecMismatchDetector implements IssueDetector {
-    #private;
-    readonly UNKNOWN_DECODER = "unknown";
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-    private setLastDecoderWithIssue;
-    private hadLastDecoderWithIssue;
-}
-export default VideoCodecMismatchDetector;

package/dist/engine/wid/lib/NetworkScoresCalculator.d.ts

@@ -1,9 +0,0 @@
-import { NetworkScores, NetworkScoresCalculator as INetworkScoresCalculator, WebRTCStatsParsed } from '../types';
-declare class NetworkScoresCalculator implements INetworkScoresCalculator {
-    #private;
-    calculate(data: WebRTCStatsParsed): NetworkScores;
-    private calcucateOutboundScore;
-    private calculateInboundScore;
-    private calculateMOS;
-}
-export default NetworkScoresCalculator;

package/dist/engine/wid/lib/PeriodicWebRTCStatsReporter.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { CompositeStatsParser } from '../types';
-interface PeriodicWebRTCStatsReporterParams {
-    compositeStatsParser: CompositeStatsParser;
-    getStatsInterval?: number;
-}
-declare class PeriodicWebRTCStatsReporter extends EventEmitter {
-    static readonly STATS_REPORT_READY_EVENT = "stats-report-ready";
-    private isStopped;
-    private reportTimer;
-    private readonly getStatsInterval;
-    private readonly compositeStatsParser;
-    constructor(params: PeriodicWebRTCStatsReporterParams);
-    get isRunning(): boolean;
-    startReporting(): void;
-    stopReporting(): void;
-    private parseReports;
-}
-export default PeriodicWebRTCStatsReporter;

package/dist/engine/wid/lib/parser/CompositeRTCStatsParser.d.ts

@@ -1,22 +0,0 @@
-import { CompositeStatsParser, ConnectionInfo, StatsParser, StatsReportItem } from '../../types';
-export interface AddConnectionPayload {
-    id?: string;
-    pc: RTCPeerConnection;
-}
-export interface RemoveConnectionPayload {
-    pc: RTCPeerConnection;
-}
-interface CompositeRTCStatsParserParams {
-    statsParser: StatsParser;
-}
-declare class CompositeRTCStatsParser implements CompositeStatsParser {
-    private readonly connections;
-    private readonly statsParser;
-    constructor(params: CompositeRTCStatsParserParams);
-    listConnections(): ConnectionInfo[];
-    addPeerConnection(payload: AddConnectionPayload): void;
-    removePeerConnection(payload: RemoveConnectionPayload): void;
-    parse(): Promise<StatsReportItem[]>;
-    private removeConnectionsByIndexes;
-}
-export default CompositeRTCStatsParser;

package/dist/engine/wid/lib/parser/RTCStatsParser.d.ts

@@ -1,20 +0,0 @@
-import { ConnectionInfo, StatsParser, StatsReportItem } from '../../types';
-import { Logger } from '../../../../types/common';
-interface WebRTCStatsParserParams {
-    logger: Logger;
-}
-declare class RTCStatsParser implements StatsParser {
-    private readonly prevStats;
-    private readonly allowedReportTypes;
-    private readonly logger;
-    constructor(params: WebRTCStatsParserParams);
-    parse(connection: ConnectionInfo): Promise<StatsReportItem | undefined>;
-    private getConnectionStats;
-    private mapReportsStats;
-    private updateMappedStatsWithReportItemData;
-    private getMediaType;
-    private propagateStatsWithRateValues;
-    private mapConnectionStatsIfNecessary;
-    private prepareConnectionStats;
-}
-export default RTCStatsParser;

package/dist/engine/wid/lib/parser/utils.d.ts

@@ -1,7 +0,0 @@
-interface WithTS {
-    timestamp: number;
-}
-export declare const checkIsConnectionClosed: (pc: RTCPeerConnection) => boolean;
-export declare const calcValueRate: <T extends WithTS>(stats: T, prevStats: T | undefined, statPropName: keyof T) => number;
-export declare const calcBitrate: <T extends WithTS>(stats: T, prevStats: T | undefined, statPropName: keyof T) => number;
-export {};