@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.4.8 → 1.0.1

package/dist/types/PeerConnectionController/InboundRTPStats.d.ts

@@ -2,140 +2,143 @@
  * Inbound Audio Stats collected from the RTC Stats Report
  */
 export declare class InboundAudioStats {
-    audioLevel: number;
+    audioLevel: number | undefined;
     bytesReceived: number;
     codecId: string;
-    concealedSamples: number;
-    concealmentEvents: number;
-    fecPacketsDiscarded: number;
-    fecPacketsReceived: number;
+    concealedSamples: number | undefined;
+    concealmentEvents: number | undefined;
+    fecPacketsDiscarded: number | undefined;
+    fecPacketsReceived: number | undefined;
     headerBytesReceived: number;
     id: string;
-    insertedSamplesForDeceleration: number;
+    insertedSamplesForDeceleration: number | undefined;
     jitter: number;
     jitterBufferDelay: number;
     jitterBufferEmittedCount: number;
-    jitterBufferMinimumDelay: number;
-    jitterBufferTargetDelay: number;
+    jitterBufferMinimumDelay: number | undefined;
+    jitterBufferTargetDelay: number | undefined;
     kind: string;
     lastPacketReceivedTimestamp: number;
-    mediaType: string;
+    mediaType: string | undefined;
     mid: string;
-    packetsDiscarded: number;
+    packetsDiscarded: number | undefined;
     packetsLost: number;
     packetsReceived: number;
-    removedSamplesForAcceleration: number;
-    silentConcealedSamples: number;
+    removedSamplesForAcceleration: number | undefined;
+    silentConcealedSamples: number | undefined;
     ssrc: number;
     timestamp: number;
-    totalAudioEnergy: number;
-    totalSamplesDuration: number;
-    totalSamplesReceived: number;
-    trackIdentifier: string;
-    transportId: string;
+    totalAudioEnergy: number | undefined;
+    totalSamplesDuration: number | undefined;
+    totalSamplesReceived: number | undefined;
+    trackIdentifier: string | undefined;
+    transportId: string | undefined;
     type: string;
-    bitrate: number;
+    bitrate: number | undefined;
 }
 /**
  * Inbound Video Stats collected from the RTC Stats Report
  */
 export declare class InboundVideoStats {
     bytesReceived: number;
-    codecId: string;
-    firCount: number;
-    frameHeight: number;
-    frameWidth: number;
-    framesAssembledFromMultiplePackets: number;
-    framesDecoded: number;
-    framesDropped: number;
-    framesPerSecond: number;
-    framesReceived: number;
-    freezeCount: number;
-    googTimingFrameInfo: string;
+    codecId: string | undefined;
+    firCount: number | undefined;
+    frameHeight: number | undefined;
+    frameWidth: number | undefined;
+    framesAssembledFromMultiplePackets: number | undefined;
+    framesDecoded: number | undefined;
+    framesDropped: number | undefined;
+    framesPerSecond: number | undefined;
+    framesReceived: number | undefined;
+    freezeCount: number | undefined;
+    googTimingFrameInfo: string | undefined;
     headerBytesReceived: number;
     id: string;
     jitter: number;
     jitterBufferDelay: number;
     jitterBufferEmittedCount: number;
-    keyFramesDecoded: number;
+    keyFramesDecoded: number | undefined;
     kind: string;
-    lastPacketReceivedTimestamp: number;
-    mediaType: string;
+    lastPacketReceivedTimestamp: number | undefined;
+    mediaType: string | undefined;
     mid: string;
-    nackCount: number;
+    nackCount: number | undefined;
     packetsLost: number;
     packetsReceived: number;
-    pauseCount: number;
-    pliCount: number;
+    pauseCount: number | undefined;
+    pliCount: number | undefined;
     ssrc: number;
     timestamp: number;
-    totalAssemblyTime: number;
-    totalDecodeTime: number;
-    totalFreezesDuration: number;
-    totalInterFrameDelay: number;
-    totalPausesDuration: number;
-    totalProcessingDelay: number;
-    totalSquaredInterFrameDelay: number;
-    trackIdentifier: string;
-    transportId: string;
+    totalAssemblyTime: number | undefined;
+    totalDecodeTime: number | undefined;
+    totalFreezesDuration: number | undefined;
+    totalInterFrameDelay: number | undefined;
+    totalPausesDuration: number | undefined;
+    totalProcessingDelay: number | undefined;
+    totalSquaredInterFrameDelay: number | undefined;
+    trackIdentifier: string | undefined;
+    transportId: string | undefined;
     type: string;
-    bitrate: number;
+    bitrate: number | undefined;
 }
 /**
  * Inbound Stats collected from the RTC Stats Report
  */
 export declare class InboundRTPStats {
     bytesReceived: number;
-    codecId: string;
+    codecId: string | undefined;
     headerBytesReceived: number;
     id: string;
     jitter: number;
     jitterBufferDelay: number;
     jitterBufferEmittedCount: number;
     kind: string;
-    lastPacketReceivedTimestamp: number;
-    mediaType: string;
+    lastPacketReceivedTimestamp: number | undefined;
+    mediaType: string | undefined;
     mid: string;
     packetsLost: number;
     packetsReceived: number;
+    playoutId: string | undefined;
+    qpsum: number | undefined;
+    remoteId: string | undefined;
     ssrc: number;
     timestamp: number;
-    trackIdentifier: string;
-    transportId: string;
+    trackIdentifier: string | undefined;
+    transportId: string | undefined;
     type: string;
-    audioLevel: number;
-    concealedSamples: number;
-    concealmentEvents: number;
-    fecPacketsDiscarded: number;
-    fecPacketsReceived: number;
-    insertedSamplesForDeceleration: number;
-    jitterBufferMinimumDelay: number;
-    jitterBufferTargetDelay: number;
-    packetsDiscarded: number;
-    removedSamplesForAcceleration: number;
-    silentConcealedSamples: number;
-    totalAudioEnergy: number;
-    totalSamplesDuration: number;
-    totalSamplesReceived: number;
-    firCount: number;
-    frameHeight: number;
-    frameWidth: number;
-    framesAssembledFromMultiplePackets: number;
-    framesDecoded: number;
-    framesDropped: number;
-    framesPerSecond: number;
-    framesReceived: number;
-    freezeCount: number;
-    googTimingFrameInfo: string;
-    keyFramesDecoded: number;
-    nackCount: number;
-    pauseCount: number;
-    pliCount: number;
-    totalAssemblyTime: number;
-    totalDecodeTime: number;
-    totalFreezesDuration: number;
-    totalInterFrameDelay: number;
-    totalPausesDuration: number;
-    totalProcessingDelay: number;
-    totalSquaredInterFrameDelay: number;
+    audioLevel: number | undefined;
+    concealedSamples: number | undefined;
+    concealmentEvents: number | undefined;
+    fecPacketsDiscarded: number | undefined;
+    fecPacketsReceived: number | undefined;
+    insertedSamplesForDeceleration: number | undefined;
+    jitterBufferMinimumDelay: number | undefined;
+    jitterBufferTargetDelay: number | undefined;
+    packetsDiscarded: number | undefined;
+    removedSamplesForAcceleration: number | undefined;
+    silentConcealedSamples: number | undefined;
+    totalAudioEnergy: number | undefined;
+    totalSamplesDuration: number | undefined;
+    totalSamplesReceived: number | undefined;
+    firCount: number | undefined;
+    frameHeight: number | undefined;
+    frameWidth: number | undefined;
+    framesAssembledFromMultiplePackets: number | undefined;
+    framesDecoded: number | undefined;
+    framesDropped: number | undefined;
+    framesPerSecond: number | undefined;
+    framesReceived: number | undefined;
+    freezeCount: number | undefined;
+    googTimingFrameInfo: string | undefined;
+    keyFramesDecoded: number | undefined;
+    nackCount: number | undefined;
+    pauseCount: number | undefined;
+    pliCount: number | undefined;
+    totalAssemblyTime: number | undefined;
+    totalDecodeTime: number | undefined;
+    totalFreezesDuration: number | undefined;
+    totalInterFrameDelay: number | undefined;
+    totalPausesDuration: number | undefined;
+    totalProcessingDelay: number | undefined;
+    totalSquaredInterFrameDelay: number | undefined;
 }

package/dist/types/PeerConnectionController/LatencyCalculator.d.ts

@@ -0,0 +1,87 @@
+import { AggregatedStats } from './AggregatedStats';
+/**
+ * FrameTimingInfo is a Chromium-specific set of WebRTC stats useful for latency calculation. It is stored in WebRTC stats as `googTimingFrameInfo`.
+ * It is defined as an RTP header extension here: https://webrtc.googlesource.com/src/+/refs/heads/main/docs/native-code/rtp-hdrext/video-timing/README.md
+ * It is defined in source code here: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/api/video/video_timing.cc;l=82;drc=8d399817282e3c12ed54eb23ec42a5e418298ec6
+ * It is discussed by its author here: https://github.com/w3c/webrtc-provisional-stats/issues/40#issuecomment-1272916692
+ * In summary it a comma-delimited string that contains the following (in this order):
+ * 1)  RTP timestamp: the RTP timestamp of the frame
+ * 2)  Capture time: timestamp when this frame was captured
+ * 3)  Encode start: timestamp when this frame started to be encoded
+ * 4)  Encode finish: timestamp when this frame finished encoding
+ * 5)  Packetization finish: timestamp when this frame was split into packets and was ready to be sent over the network
+ * 6)  Pacer exit: timestamp when last packet of this frame was sent over the network by the sender at this timestamp
+ * 7)  Network timestamp1: place for the SFU to mark when the frame started being forwarded. Application specific.
+ * 8)  Network timestamp2: place for the SFU to mark when the frame finished being forwarded. Application specific.
+ * 9)  Receive start: timestamp when the first packet of this frame was received
+ * 10) Receive finish: timestamp when the last packet of this frame was received
+ * 11) Decode start:  timestamp when the frame was passed to decoder
+ * 12) Decode finish:  timestamp when the frame was decoded
+ * 13) Render time:  timestamp of the projected render time for this frame
+ * 14) "is outlier": a flag for if this frame is bigger in encoded size than the average frame by at least 5x.
+ * 15) "triggered by timer": a flag for if this report was triggered by the timer (The report is sent every 200ms)
+ */
+export declare class FrameTimingInfo {
+    rtpTimestamp: number;
+    captureTimestamp: number;
+    encodeStartTimestamp: number;
+    encodeFinishTimestamp: number;
+    packetizerFinishTimestamp: number;
+    pacerExitTimestamp: number;
+    networkTimestamp1: number;
+    networkTimestamp2: number;
+    receiveStart: number;
+    receiveFinish: number;
+    decodeStart: number;
+    decodeFinish: number;
+    renderTime: number;
+    isOutlier: boolean;
+    isTriggeredByTimer: boolean;
+    encoderLatencyMs: number;
+    packetizeLatencyMs: number;
+    pacerLatencyMs: number;
+    captureToSendLatencyMs: number;
+}
+/**
+ * Calculates a combination of latency statistics using purely WebRTC API.
+ */
+export declare class LatencyCalculator {
+    private latestSenderRecvClockOffset;
+    calculate(stats: AggregatedStats, receivers: RTCRtpReceiver[]): LatencyInfo;
+    private extractFrameTimingInfo;
+    private calculateSenderLatency;
+    /**
+     * Find the first valid ssrc or csrc that has capture time fields present from abs-capture-time header extension.
+     * @param receivers The RTP receviers this peer connection has.
+     * @returns A single valid ssrc or csrc that has capture time fields or null if there is none (e.g. in non-chromium browsers it will be null).
+     */
+    private getCaptureSource;
+    private calculateSenderReceiverClockOffset;
+    private getRTTMs;
+}
+/**
+ * A collection of latency information calculated using the WebRTC API.
+ * Most stats are calculated following the spec:
+ * https://w3c.github.io/webrtc-stats/#dictionary-rtcinboundrtpstreamstats-members
+ */
+export declare class LatencyInfo {
+    /**
+     * The time taken from the moment a frame is done capturing to the moment it is sent over the network.
+     * Note: This can only be calculated if both offer and answer contain the
+     * the RTP header extension for `video-timing` (Chrome only for now)
+     */
+    senderLatencyMs: number | undefined;
+    /**
+     * The time taken from the moment a frame is done capturing to the moment it is sent over the network.
+     * Note: This can only be calculated if both offer and answer contain the
+     * the RTP header extension for `abs-capture-time` (Chrome only for now)
+     */
+    senderLatencyAbsCaptureTimeMs: number | undefined;
+    rttMs: number | undefined;
+    averageProcessingDelayMs: number | undefined;
+    averageJitterBufferDelayMs: number | undefined;
+    averageDecodeLatencyMs: number | undefined;
+    averageAssemblyDelayMs: number | undefined;
+    averageE2ELatency: number | undefined;
+    frameTiming: FrameTimingInfo | undefined;
+}

package/dist/types/PeerConnectionController/OutBoundRTPStats.d.ts

@@ -1,23 +1,57 @@
 /**
- * Outbound Video Stats collected from the RTC Stats Report
+ * Outbound RTP stats collected from the RTC Stats Report under `outbound-rtp`.
+ * Wrapper around: https://developer.mozilla.org/en-US/docs/Web/API/RTCOutboundRtpStreamStats
+ * These are stats for video we are sending to a remote peer.
  */
-export declare class OutBoundVideoStats {
+export declare class OutboundRTPStats {
+    active: boolean | undefined;
+    codecId: string | undefined;
     bytesSent: number;
+    frameHeight: number | undefined;
+    frameWidth: number | undefined;
+    framesEncoded: number | undefined;
+    framesPerSecond: number | undefined;
+    framesSent: number | undefined;
+    headerBytesSent: number;
     id: string;
-    localId: string;
+    keyFramesEncoded: number | undefined;
+    kind: string;
+    mediaSourceId: string | undefined;
+    mid: string | undefined;
+    nackCount: number | undefined;
     packetsSent: number;
-    remoteTimestamp: number;
+    qpSum: number | undefined;
+    qualityLimitationDurations: number | undefined;
+    qualityLimitationReason: string | undefined;
+    remoteId: string | undefined;
+    retransmittedBytesSent: number;
+    rid: string | undefined;
+    scalabilityMode: string | undefined;
+    ssrc: string;
+    targetBitrate: number | undefined;
     timestamp: number;
+    totalEncodeTime: number | undefined;
+    totalEncodeBytesTarget: number | undefined;
+    totalPacketSendDelay: number | undefined;
+    transportId: string | undefined;
 }
 /**
- * Outbound Stats collected from the RTC Stats Report
+ * Remote outbound stats collected from the RTC Stats Report under `remote-outbound-rtp`.
+ * Wrapper around: https://developer.mozilla.org/en-US/docs/Web/API/RTCRemoteOutboundRtpStreamStats
+ * These are stats for media we are receiving from a remote peer.
  */
-export declare class OutBoundRTPStats {
+export declare class RemoteOutboundRTPStats {
+    bytesSent: number | undefined;
+    codecId: string;
+    id: string | undefined;
     kind: string;
-    bytesSent: number;
-    id: string;
-    localId: string;
-    packetsSent: number;
-    remoteTimestamp: number;
-    timestamp: number;
+    localId: string | undefined;
+    packetsSent: number | undefined;
+    remoteTimestamp: number | undefined;
+    reportsSent: number | undefined;
+    roundTripTimeMeasurements: number | undefined;
+    ssrc: string;
+    timestamp: number | undefined;
+    totalRoundTripTime: number | undefined;
+    transportId: string | undefined;
 }

package/dist/types/PeerConnectionController/PeerConnectionController.d.ts

@@ -1,5 +1,7 @@
 import { Config } from '../Config/Config';
 import { AggregatedStats } from './AggregatedStats';
+import { LatencyCalculator, LatencyInfo } from './LatencyCalculator';
+export declare const kAbsCaptureTime = "http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time";
 /**
  * Handles the Peer Connection
  */
@@ -11,6 +13,7 @@ export declare class PeerConnectionController {
     updateCodecSelection: boolean;
     videoTrack: MediaStreamTrack;
     audioTrack: MediaStreamTrack;
+    latencyCalculator: LatencyCalculator;
     /**
      * Create a new RTC Peer Connection client
      * @param options - Peer connection Options
@@ -24,7 +27,7 @@ export declare class PeerConnectionController {
      */
     createOffer(offerOptions: RTCOfferOptions, config: Config): Promise<void>;
     /**
-     *
+     * Receive offer from UE side and process it as the remote description of this peer connection
      */
     receiveOffer(offer: RTCSessionDescriptionInit, config: Config): Promise<void>;
     /**
@@ -47,6 +50,7 @@ export declare class PeerConnectionController {
      * @returns A modified Session Descriptor
      */
     mungeSDP(sdp: string, useMic: boolean): string;
+    isFirefox(): boolean;
     /**
      * When a Ice Candidate is received add to the RTC Peer Connection
      * @param iceCandidate - RTC Ice Candidate from the Signaling Server
@@ -121,16 +125,26 @@ export declare class PeerConnectionController {
      * @param event - Aggregated Stats
      */
     onVideoStats(event: AggregatedStats): void;
+    /**
+     * And override event for when latency info is calculated
+     * @param latencyInfo - Calculated latency information.
+     */
+    onLatencyCalculated(latencyInfo: LatencyInfo): void;
     /**
      * Event to send the RTC offer to the Signaling server
      * @param offer - RTC Offer
      */
     onSendWebRTCOffer(offer: RTCSessionDescriptionInit): void;
     /**
-     * Event to send the RTC Answer to the Signaling server
+     * Event fired when remote offer description is set.
+     * @param offer - RTC Offer
+     */
+    onSetRemoteDescription(offer: RTCSessionDescriptionInit): void;
+    /**
+     * Event fire when local description answer is set.
      * @param answer - RTC Answer
      */
-    onSendWebRTCAnswer(answer: RTCSessionDescriptionInit): void;
+    onSetLocalDescription(answer: RTCSessionDescriptionInit): void;
     /**
      * An override for showing the Peer connection connecting Overlay
      */

package/dist/types/PixelStreaming/PixelStreaming.d.ts

@@ -8,6 +8,7 @@ import { WebXRController } from '../WebXR/WebXRController';
 import { MessageDirection } from '../UeInstanceMessage/StreamMessageController';
 import { DataChannelLatencyTestConfig, DataChannelLatencyTestController } from '../DataChannel/DataChannelLatencyTestController';
 import { DataChannelLatencyTestResponse } from '../DataChannel/DataChannelLatencyTestResults';
+import { LatencyInfo } from '../PeerConnectionController/LatencyCalculator';
 export interface PixelStreamingOverrides {
     /** The DOM element where Pixel Streaming video and user input event handlers are attached to.
      * You can give an existing DOM element here. If not given, the library will create a new div element
@@ -109,15 +110,27 @@ export declare class PixelStreaming {
     muteCamera(): void;
     private setCameraMuted;
     /**
-     * Emit an event on auto connecting
+     * Internal function to emit an event when auto connecting occurs
      */
     _onWebRtcAutoConnect(): void;
     /**
-     * Set up functionality to happen when receiving a webRTC answer
+     * Internal function to emit an event for when SDP negotiation is fully finished.
      */
     _onWebRtcSdp(): void;
     /**
-     * Emits a StreamLoading event
+     * Internal function to emit an SDP offer after it has been set.
+     */
+    _onWebRtcSdpOffer(offer: RTCSessionDescriptionInit): void;
+    /**
+     * Internal function to emit an SDP answer after it has been set.
+     */
+    _onWebRtcSdpAnswer(answer: RTCSessionDescriptionInit): void;
+    /**
+     * Internal function call to emit a `latencyCalculated` event.
+     */
+    _onLatencyCalculated(latencyInfo: LatencyInfo): void;
+    /**
+     * Internal function to emits a StreamLoading event
      */
     _onStreamLoading(): void;
     /**

package/dist/types/Util/EventEmitter.d.ts

@@ -2,6 +2,7 @@ import { FlagsIds, NumericParametersIds, OptionParametersIds, TextParametersIds
 import { LatencyTestResults } from '../DataChannel/LatencyTestResults';
 import { AggregatedStats } from '../PeerConnectionController/AggregatedStats';
 import { InitialSettings } from '../DataChannel/InitialSettings';
+import { LatencyInfo } from '../PeerConnectionController/LatencyCalculator';
 import { Messages } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
 import { SettingFlag } from '../Config/SettingFlag';
 import { SettingNumber } from '../Config/SettingNumber';
@@ -65,6 +66,28 @@ export declare class WebRtcSdpEvent extends Event {
     readonly type: 'webRtcSdp';
     constructor();
 }
+/**
+ * An event that is emitted after the SDP answer is set.
+ */
+export declare class WebRtcSdpAnswerEvent extends Event {
+    readonly type: 'webRtcSdpAnswer';
+    readonly data: {
+        /** The sdp answer */
+        sdp: RTCSessionDescriptionInit;
+    };
+    constructor(data: WebRtcSdpAnswerEvent['data']);
+}
+/**
+ * An event that is emitted after the SDP offer is set.
+ */
+export declare class WebRtcSdpOfferEvent extends Event {
+    readonly type: 'webRtcSdpOffer';
+    readonly data: {
+        /** The sdp offer */
+        sdp: RTCSessionDescriptionInit;
+    };
+    constructor(data: WebRtcSdpOfferEvent['data']);
+}
 /**
  * An event that is emitted when auto connecting.
  */
@@ -280,6 +303,16 @@ export declare class LatencyTestResultEvent extends Event {
     };
     constructor(data: LatencyTestResultEvent['data']);
 }
+/**
+ * An event that is emitted everytime latency is calculated using the WebRTC stats API.
+ */
+export declare class LatencyCalculatedEvent extends Event {
+    readonly type: 'latencyCalculated';
+    readonly data: {
+        latencyInfo: LatencyInfo;
+    };
+    constructor(data: LatencyCalculatedEvent['data']);
+}
 /**
  * An event that is emitted when receiving data channel latency test response from server.
  * This event is handled by DataChannelLatencyTestController
@@ -408,7 +441,7 @@ export declare class WebRtcTCPRelayDetectedEvent extends Event {
     readonly type: 'webRtcTCPRelayDetected';
     constructor();
 }
-export type PixelStreamingEvent = AfkWarningActivateEvent | AfkWarningUpdateEvent | AfkWarningDeactivateEvent | AfkTimedOutEvent | VideoEncoderAvgQPEvent | WebRtcSdpEvent | WebRtcAutoConnectEvent | WebRtcConnectingEvent | WebRtcConnectedEvent | WebRtcFailedEvent | WebRtcDisconnectedEvent | DataChannelOpenEvent | DataChannelCloseEvent | DataChannelErrorEvent | VideoInitializedEvent | StreamLoadingEvent | StreamPreConnectEvent | StreamReconnectEvent | StreamPreDisconnectEvent | PlayStreamErrorEvent | PlayStreamEvent | PlayStreamRejectedEvent | LoadFreezeFrameEvent | HideFreezeFrameEvent | StatsReceivedEvent | StreamerListMessageEvent | StreamerIDChangedMessageEvent | LatencyTestResultEvent | DataChannelLatencyTestResponseEvent | DataChannelLatencyTestResultEvent | SubscribeFailedEvent | InitialSettingsEvent | SettingsChangedEvent | XrSessionStartedEvent | XrSessionEndedEvent | XrFrameEvent | PlayerCountEvent | WebRtcTCPRelayDetectedEvent;
+export type PixelStreamingEvent = AfkWarningActivateEvent | AfkWarningUpdateEvent | AfkWarningDeactivateEvent | AfkTimedOutEvent | VideoEncoderAvgQPEvent | WebRtcSdpEvent | WebRtcSdpOfferEvent | WebRtcSdpAnswerEvent | WebRtcAutoConnectEvent | WebRtcConnectingEvent | WebRtcConnectedEvent | WebRtcFailedEvent | WebRtcDisconnectedEvent | DataChannelOpenEvent | DataChannelCloseEvent | DataChannelErrorEvent | VideoInitializedEvent | StreamLoadingEvent | StreamPreConnectEvent | StreamReconnectEvent | StreamPreDisconnectEvent | PlayStreamErrorEvent | PlayStreamEvent | PlayStreamRejectedEvent | LoadFreezeFrameEvent | HideFreezeFrameEvent | StatsReceivedEvent | StreamerListMessageEvent | StreamerIDChangedMessageEvent | LatencyCalculatedEvent | LatencyTestResultEvent | DataChannelLatencyTestResponseEvent | DataChannelLatencyTestResultEvent | SubscribeFailedEvent | InitialSettingsEvent | SettingsChangedEvent | XrSessionStartedEvent | XrSessionEndedEvent | XrFrameEvent | PlayerCountEvent | WebRtcTCPRelayDetectedEvent;
 export declare class PixelStreamingEventEmitter extends EventTarget {
     /**
      * Dispatch a new event.

package/dist/types/VideoPlayer/VideoPlayer.d.ts

@@ -4,7 +4,7 @@ import { Config } from '../Config/Config';
  */
 declare global {
     interface HTMLElement {
-        mozRequestPointerLock(options: PointerLockOptions): Promise<void>;
+        mozRequestPointerLock(): Promise<void>;
     }
 }
 /**

package/dist/types/__test__/mockMediaStream.d.ts

@@ -0,0 +1,49 @@
+export declare class MockMediaStreamImpl implements MediaStream {
+    active: boolean;
+    id: string;
+    constructor(data?: MediaStream | MediaStreamTrack[]);
+    onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+    onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+    addTrack(track: MediaStreamTrack): void;
+    clone(): MediaStream;
+    getAudioTracks(): MediaStreamTrack[];
+    getTrackById(trackId: string): MediaStreamTrack | null;
+    getTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    removeTrack(track: MediaStreamTrack): void;
+    addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+}
+export declare class MockMediaStreamTrackImpl implements MediaStreamTrack {
+    contentHint: string;
+    enabled: boolean;
+    id: string;
+    kind: string;
+    label: string;
+    muted: boolean;
+    readyState: MediaStreamTrackState;
+    constructor();
+    onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    applyConstraints(constraints?: MediaTrackConstraints | undefined): Promise<void>;
+    clone(): MediaStreamTrack;
+    getCapabilities(): MediaTrackCapabilities;
+    getConstraints(): MediaTrackConstraints;
+    getSettings(): MediaTrackSettings;
+    stop(): void;
+    addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+}
+export declare const mockMediaStream: () => void;
+export declare const unmockMediaStream: () => void;
+export declare const mockHTMLMediaElement: (options: {
+    ableToPlay: boolean;
+    readyState?: number;
+}) => void;