@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.1.3 → 0.2.1

package/types/Inputs/InputClassesFactory.d.ts

@@ -1,26 +1,25 @@
-import { FakeTouchController } from './FakeTouchController';
 import { KeyboardController } from './KeyboardController';
 import { MouseController } from './MouseController';
-import { TouchController } from './TouchController';
-import { GamePadController } from './GamepadController';
+import { GamepadController } from './GamepadController';
 import { Config, ControlSchemeType } from '../Config/Config';
-import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
 import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { IInputController } from './IInputController';
 /**
  * Class for making and setting up input class types
  */
 export declare class InputClassesFactory {
     toStreamerMessagesProvider: StreamMessageController;
     videoElementProvider: VideoPlayer;
-    coordinateConverter: CoordinateConverter;
+    coordinateConverter: InputCoordTranslator;
     activeKeys: ActiveKeys;
     /**
      * @param toStreamerMessagesProvider - Stream message instance
      * @param videoElementProvider - Video Player instance
      * @param coordinateConverter - A coordinateConverter instance
      */
-    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: CoordinateConverter);
+    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: InputCoordTranslator);
     /**
      * Registers browser key events.
      */
@@ -34,11 +33,11 @@ export declare class InputClassesFactory {
      * register touch events
      * @param fakeMouseTouch - the faked mouse touch event
      */
-    registerTouch(fakeMouseTouch: boolean, videoElementParentClientRect: DOMRect): FakeTouchController | TouchController;
+    registerTouch(fakeMouseTouch: boolean): IInputController;
     /**
      * registers a gamepad
      */
-    registerGamePad(): GamePadController;
+    registerGamePad(): GamepadController;
 }
 /**
  * A class that keeps track of current active keys

package/types/Inputs/KeyCodes.d.ts

@@ -0,0 +1,5 @@
+interface ICodeToKeyCode {
+    [key: string]: number;
+}
+export declare const CodeToKeyCode: ICodeToKeyCode;
+export {};

package/types/Inputs/KeyboardController.d.ts

@@ -1,62 +1,34 @@
 import { ActiveKeys } from './InputClassesFactory';
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
 import { Config } from '../Config/Config';
-interface ICodeToKeyCode {
-    [key: string]: number;
-}
+import { IInputController } from './IInputController';
 /**
  * Handles the Keyboard Inputs for the document
  */
-export declare class KeyboardController {
-    toStreamerMessagesProvider: StreamMessageController;
-    activeKeysProvider: ActiveKeys;
+export declare class KeyboardController implements IInputController {
+    streamMessageController: StreamMessageController;
+    activeKeys: ActiveKeys;
     config: Config;
-    private keyboardEventListenerTracker;
-    CodeToKeyCode: ICodeToKeyCode;
-    /**
-     * @param toStreamerMessagesProvider Stream message provider class object
-     * @param config The applications configuration. We're interested in the suppress browser keys option
-     * @param activeKeysProvider Active keys provider class object
-     */
-    constructor(toStreamerMessagesProvider: StreamMessageController, config: Config, activeKeysProvider: ActiveKeys);
-    /**
-     * Registers document keyboard events with the controller
-     */
-    registerKeyBoardEvents(): void;
-    /**
-     * Unregister document keyboard events.
-     */
-    unregisterKeyBoardEvents(): void;
-    /**
-     * Handles When a key is down
-     * @param keyboardEvent - Keyboard event
-     */
-    handleOnKeyDown(keyboardEvent: KeyboardEvent): void;
-    /**
-     * handles when a key is up
-     * @param keyboardEvent - Keyboard event
-     */
-    handleOnKeyUp(keyboardEvent: KeyboardEvent): void;
-    /**
-     * Handles when a key is press
-     * @param keyboard - Keyboard Event
-     */
-    handleOnKeyPress(keyboard: KeyboardEvent): void;
-    /**
-     * Handle whenever composition ends (eg chinese simplified)
-     * @param compositionEvent - the composition event
-     */
-    handleOnCompositionEnd(compositionEvent: CompositionEvent): void;
+    onKeyDownListener: (event: KeyboardEvent) => void;
+    onKeyUpListener: (event: KeyboardEvent) => void;
+    onKeyPressListener: (event: KeyboardEvent) => void;
+    onCompositionEndListener: (event: KeyboardEvent) => void;
+    constructor(streamMessageController: StreamMessageController, config: Config, activeKeys: ActiveKeys);
+    register(): void;
+    unregister(): void;
+    private handleOnKeyDown;
+    private handleOnKeyUp;
+    private handleOnKeyPress;
+    private handleOnCompositionEnd;
     /**
      * Gets the Keycode of the Key pressed
      * @param keyboardEvent - Key board Event
      * @returns - the key code of the Key
      */
-    getKeycode(keyboardEvent: KeyboardEvent): number;
+    private getKeycode;
     /**
      * Browser keys do not have a charCode so we only need to test keyCode.
      * @param keyCode - the browser keycode number
      */
-    isKeyCodeBrowserKey(keyCode: number): boolean;
+    private isKeyCodeBrowserKey;
 }
-export {};

package/types/Inputs/MouseController.d.ts

@@ -1,75 +1,40 @@
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
-import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
 import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
 import type { ActiveKeys } from './InputClassesFactory';
+import { IInputController } from './IInputController';
 /**
- * Handles the Mouse Inputs for the document
+ * Extra types for Document and WheelEvent
  */
-export declare class MouseController {
-    videoElementProvider: VideoPlayer;
-    toStreamerMessagesProvider: StreamMessageController;
-    coordinateConverter: CoordinateConverter;
-    activeKeysProvider: ActiveKeys;
-    private mouseEventListenerTracker;
-    /**
-     * @param toStreamerMessagesProvider - Stream message instance
-     * @param videoElementProvider - Video Player instance
-     * @param normalizeAndQuantize - A normalize and quantize instance
-     */
-    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: CoordinateConverter, activeKeysProvider: ActiveKeys);
-    /**
-     * Clears all the click events on the current video element parent div
-     */
-    unregisterMouseEvents(): void;
-    /**
-     * Register a locked mouse class
-     * @param mouseController - a mouse controller instance
-     * @param playerStyleAttributesProvider - a player style attributes instance
-     */
-    registerLockedMouseEvents(mouseController: MouseController): void;
-    /**
-     * Register a hovering mouse class
-     * @param mouseController - A mouse controller object
-     */
-    registerHoveringMouseEvents(mouseController: MouseController): void;
-    /**
-     * Set the mouse enter and mouse leave events
-     */
+declare global {
+    interface Document {
+        mozPointerLockElement: unknown;
+        mozExitPointerLock?(): void;
+    }
+    interface WheelEvent {
+        wheelDelta: number;
+    }
+}
+/**
+ * The base class for mouse controllers. Since there is a bunch of shared behaviour between locked and
+ * hover mouse controllers this is where that shared behaviour lives.
+ */
+export declare class MouseController implements IInputController {
+    videoPlayer: VideoPlayer;
+    streamMessageController: StreamMessageController;
+    coordinateConverter: InputCoordTranslator;
+    activeKeys: ActiveKeys;
+    onEnterListener: (event: MouseEvent) => void;
+    onLeaveListener: (event: MouseEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator, activeKeys: ActiveKeys);
+    register(): void;
+    unregister(): void;
     registerMouseEnterAndLeaveEvents(): void;
-    /**
-     * Handle when a mouse button is released
-     * @param buttons - Mouse Button
-     * @param X - Mouse pointer X coordinate
-     * @param Y - Mouse pointer Y coordinate
-     */
-    releaseMouseButtons(buttons: number, X: number, Y: number): void;
-    /**
-     * Handle when a mouse button is pressed
-     * @param buttons - Mouse Button
-     * @param X - Mouse pointer X coordinate
-     * @param Y - Mouse pointer Y coordinate
-     */
-    pressMouseButtons(buttons: number, X: number, Y: number): void;
-    /**
-     * Handles mouse enter
-     */
-    sendMouseEnter(): void;
-    /**
-     * Handles mouse Leave
-     */
-    sendMouseLeave(): void;
-    /**
-     * Handles when a mouse button is pressed down
-     * @param button - Mouse Button Pressed
-     * @param X  - Mouse X Coordinate
-     * @param Y  - Mouse Y Coordinate
-     */
-    sendMouseDown(button: number, X: number, Y: number): void;
-    /**
-     * Handles when a mouse button is pressed up
-     * @param button - Mouse Button Pressed
-     * @param X  - Mouse X Coordinate
-     * @param Y  - Mouse Y Coordinate
-     */
-    sendMouseUp(button: number, X: number, Y: number): void;
+    unregisterMouseEnterAndLeaveEvents(): void;
+    private onMouseEnter;
+    private onMouseLeave;
+    private releaseMouseButtons;
+    private pressMouseButtons;
+    private sendMouseDown;
+    private sendMouseUp;
 }

package/types/Inputs/MouseControllerHovering.d.ts

@@ -0,0 +1,26 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import type { ActiveKeys } from './InputClassesFactory';
+import { MouseController } from './MouseController';
+/**
+ * A mouse controller that allows the mouse to freely float over the video document.
+ */
+export declare class MouseControllerHovering extends MouseController {
+    videoElementParent: HTMLDivElement;
+    onMouseUpListener: (event: MouseEvent) => void;
+    onMouseDownListener: (event: MouseEvent) => void;
+    onMouseDblClickListener: (event: MouseEvent) => void;
+    onMouseWheelListener: (event: WheelEvent) => void;
+    onMouseMoveListener: (event: MouseEvent) => void;
+    onContextMenuListener: (event: MouseEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator, activeKeys: ActiveKeys);
+    register(): void;
+    unregister(): void;
+    private onMouseDown;
+    private onMouseUp;
+    private onContextMenu;
+    private onMouseMove;
+    private onMouseWheel;
+    private onMouseDblClick;
+}

package/types/Inputs/MouseControllerLocked.d.ts

@@ -0,0 +1,31 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { InputCoordTranslator, TranslatedCoordUnsigned } from '../Util/InputCoordTranslator';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import type { ActiveKeys } from './InputClassesFactory';
+import { MouseController } from './MouseController';
+/**
+ * A mouse controller that locks the mouse to the video document and prevents it from leaving the window
+ */
+export declare class MouseControllerLocked extends MouseController {
+    videoElementParent: HTMLDivElement;
+    x: number;
+    y: number;
+    normalizedCoord: TranslatedCoordUnsigned;
+    onRequestLockListener: () => void;
+    onLockStateChangeListener: () => void;
+    onMouseUpListener: (event: MouseEvent) => void;
+    onMouseDownListener: (event: MouseEvent) => void;
+    onMouseDblClickListener: (event: MouseEvent) => void;
+    onMouseWheelListener: (event: WheelEvent) => void;
+    onMouseMoveListener: (event: MouseEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator, activeKeys: ActiveKeys);
+    register(): void;
+    unregister(): void;
+    private onRequestLock;
+    private onLockStateChange;
+    private onMouseDown;
+    private onMouseUp;
+    private onMouseMove;
+    private onMouseWheel;
+    private onMouseDblClick;
+}

package/types/Inputs/TouchController.d.ts

@@ -1,53 +1,28 @@
-import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
 import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
-import { ITouchController } from './ITouchController';
+import { IInputController } from './IInputController';
 /**
- * Handles the Touch input Events
+ * The basic touch controller that handles the touch events on the document.
  */
-export declare class TouchController implements ITouchController {
-    toStreamerMessagesProvider: StreamMessageController;
-    videoElementProvider: VideoPlayer;
-    coordinateConverter: CoordinateConverter;
+export declare class TouchController implements IInputController {
+    streamMessageController: StreamMessageController;
+    videoPlayer: VideoPlayer;
+    coordinateConverter: InputCoordTranslator;
     videoElementParent: HTMLVideoElement;
     fingers: number[];
     fingerIds: Map<any, any>;
     maxByteValue: number;
-    private touchEventListenerTracker;
-    /**
-     * @param toStreamerMessagesProvider - Stream message instance
-     * @param videoElementProvider - Video Player instance
-     * @param coordinateConverter - A coordinate converter instance
-     */
-    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: CoordinateConverter);
-    /**
-     * Unregister all touch events
-     */
-    unregisterTouchEvents(): void;
-    /**
-     * Remember a touch command
-     * @param touch - the touch command
-     */
-    rememberTouch(touch: Touch): void;
-    /**
-     * Forgets a touch command
-     * @param touch - the touch command
-     */
-    forgetTouch(touch: Touch): void;
-    /**
-     * When a touch event starts
-     * @param touchEvent - the touch event being intercepted
-     */
-    onTouchStart(touchEvent: TouchEvent): void;
-    /**
-     * When a touch event ends
-     * @param touchEvent - the touch event being intercepted
-     */
-    onTouchEnd(touchEvent: TouchEvent): void;
-    /**
-     * when a moving touch event occurs
-     * @param touchEvent - the touch event being intercepted
-     */
-    onTouchMove(touchEvent: TouchEvent): void;
-    emitTouchData(type: string, touches: TouchList): void;
+    onTouchStartListener: (event: TouchEvent) => void;
+    onTouchEndListener: (event: TouchEvent) => void;
+    onTouchMoveListener: (event: TouchEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator);
+    register(): void;
+    unregister(): void;
+    private rememberTouch;
+    private forgetTouch;
+    private onTouchStart;
+    private onTouchEnd;
+    private onTouchMove;
+    private emitTouchData;
 }

package/types/Inputs/TouchControllerFake.d.ts

@@ -0,0 +1,29 @@
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { IInputController } from './IInputController';
+interface FakeTouchFinger {
+    id: number;
+    x: number;
+    y: number;
+}
+/**
+ * Allows for the usage of fake touch events
+ */
+export declare class TouchControllerFake implements IInputController {
+    streamMessageController: StreamMessageController;
+    videoPlayer: VideoPlayer;
+    coordinateConverter: InputCoordTranslator;
+    fakeTouchFinger: FakeTouchFinger;
+    videoElementParentClientRect: DOMRect;
+    onTouchStartListener: (event: TouchEvent) => void;
+    onTouchEndListener: (event: TouchEvent) => void;
+    onTouchMoveListener: (event: TouchEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator);
+    register(): void;
+    unregister(): void;
+    private onTouchStart;
+    private onTouchEnd;
+    private onTouchMove;
+}
+export {};

package/types/Inputs/XRGamepadController.d.ts

@@ -11,12 +11,5 @@ export declare class XRGamepadController {
      * @param toStreamerMessagesProvider - Stream message instance
      */
     constructor(toStreamerMessagesProvider: StreamMessageController);
-    /**
-     * Deep copies the values from a gamepad by first converting it to a JSON object and then back to a gamepad
-     *
-     * @param gamepad the original gamepad
-     * @returns a new gamepad object, populated with the original gamepads values
-     */
-    static deepCopyGamepad(gamepad: Gamepad): Gamepad;
     updateStatus(source: XRInputSource, frame: XRFrame, refSpace: XRReferenceSpace): void;
 }

package/types/PeerConnectionController/PeerConnectionController.d.ts

@@ -102,11 +102,20 @@ export declare class PeerConnectionController {
      * @param datachannelEvent - The peer's data channel
      */
     onDataChannel(datachannelEvent: RTCDataChannelEvent): void;
+    /**
+     * Find the intersection between UE and browser codecs, with fuzzy matching if some parameters are mismatched.
+     * @param sdp The remote sdp
+     * @returns The intersection between browser supported codecs and ue supported codecs.
+     */
+    fuzzyIntersectUEAndBrowserCodecs(sdp: RTCSessionDescriptionInit): string[];
     /**
      * Setup tracks on the RTC Peer Connection
      * @param useMic - is mic in use
+     * @param useCamera - is webcam in use
      */
-    setupTransceiversAsync(useMic: boolean): Promise<void>;
+    setupTransceiversAsync(useMic: boolean, useCamera: boolean): Promise<void>;
+    setupVideoSender(hasVideoReceiver: boolean): Promise<void>;
+    setupAudioSender(hasAudioReceiver: boolean): Promise<void>;
     /**
      * And override event for when the video stats are fired
      * @param event - Aggregated Stats

package/types/PixelStreaming/PixelStreaming.d.ts

@@ -6,8 +6,8 @@ import { InitialSettings } from '../DataChannel/InitialSettings';
 import { PixelStreamingEvent, StatsReceivedEvent } from '../Util/EventEmitter';
 import { WebXRController } from '../WebXR/WebXRController';
 import { MessageDirection } from '../UeInstanceMessage/StreamMessageController';
-import { DataChannelLatencyTestConfig, DataChannelLatencyTestController } from "../DataChannel/DataChannelLatencyTestController";
-import { DataChannelLatencyTestResponse } from "../DataChannel/DataChannelLatencyTestResults";
+import { DataChannelLatencyTestConfig, DataChannelLatencyTestController } from '../DataChannel/DataChannelLatencyTestController';
+import { DataChannelLatencyTestResponse } from '../DataChannel/DataChannelLatencyTestResults';
 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
@@ -97,6 +97,17 @@ export declare class PixelStreaming {
     unmuteMicrophone(forceEnable?: boolean): void;
     muteMicrophone(): void;
     private setMicrophoneMuted;
+    /**
+     * Will unmute the video track which is sent to Unreal Engine.
+     * By default, will only unmute an existing video track.
+     *
+     * @param forceEnable Can be used for cases when this object wasn't initialized with a video track.
+     * If this parameter is true, the connection will be restarted with a camera.
+     * Warning: this takes some time, as a full renegotiation and reconnection will happen.
+     */
+    unmuteCamera(forceEnable?: boolean): void;
+    muteCamera(): void;
+    private setCameraMuted;
     /**
      * Emit an event on auto connecting
      */
@@ -244,6 +255,7 @@ export declare class PixelStreaming {
      * @param signallingUrlBuilderFunc A function that generates a signalling server url.
      */
     setSignallingUrlBuilder(signallingUrlBuilderFunc: () => string): void;
+    get webRtcController(): WebRtcPlayerController;
     /**
      * Public getter for the websocket controller. Access to this property allows you to send
      * custom websocket messages.

package/types/UI/OnScreenKeyboard.d.ts

@@ -1,4 +1,4 @@
-import { UnquantizedDenormalizedUnsignedCoord } from '../Util/CoordinateConverter';
+import { UntranslatedCoordUnsigned } from '../Util/InputCoordTranslator';
 /**
  * Class for handling on screen keyboard usage
  */
@@ -16,7 +16,7 @@ export declare class OnScreenKeyboard {
      * @param y the y axis point
      * @returns unquantizeAndDenormalizeUnsigned object
      */
-    unquantizeAndDenormalizeUnsigned(x: number, y: number): UnquantizedDenormalizedUnsignedCoord;
+    unquantizeAndDenormalizeUnsigned(x: number, y: number): UntranslatedCoordUnsigned;
     /**
      * Creates on screen keyboard helpers
      * @param videoElementParent The div element the video player i injected into

package/types/Util/EventEmitter.d.ts

@@ -8,7 +8,7 @@ import { SettingFlag } from '../Config/SettingFlag';
 import { SettingNumber } from '../Config/SettingNumber';
 import { SettingText } from '../Config/SettingText';
 import { SettingOption } from '../Config/SettingOption';
-import { DataChannelLatencyTestResponse, DataChannelLatencyTestResult } from "../DataChannel/DataChannelLatencyTestResults";
+import { DataChannelLatencyTestResponse, DataChannelLatencyTestResult } from '../DataChannel/DataChannelLatencyTestResults';
 /**
  * An event that is emitted when AFK disconnect is about to happen.
  * Can be cancelled by calling the callback function provided as part of the event.

package/types/Util/IURLSearchParams.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A case insensitive, partial implementation of URLSearchParams
+ */
+export declare class IURLSearchParams {
+    _urlParams: Record<string, string>;
+    constructor(search: string);
+    has(name: string): boolean;
+    get(name: string): string | null;
+}

package/types/Util/InputCoordTranslator.d.ts

@@ -0,0 +1,29 @@
+export interface RectSize {
+    width: number;
+    height: number;
+}
+export interface TranslatedCoordUnsigned {
+    inRange: boolean;
+    x: number;
+    y: number;
+}
+export interface TranslatedCoordSigned {
+    x: number;
+    y: number;
+}
+export interface UntranslatedCoordUnsigned {
+    x: number;
+    y: number;
+}
+/**
+ * Converts coordinates from element relative coordinates to values normalized within the value range of a short (and back again)
+ */
+export declare class InputCoordTranslator {
+    playerSize: RectSize;
+    ratio: number;
+    playerIsLarger: boolean;
+    reconfigure(playerSize: RectSize, videoSize: RectSize): void;
+    translateUnsigned(x: number, y: number): TranslatedCoordUnsigned;
+    translateSigned(x: number, y: number): TranslatedCoordSigned;
+    untranslateUnsigned(x: number, y: number): UntranslatedCoordUnsigned;
+}

package/types/VideoPlayer/StreamController.d.ts

@@ -1,4 +1,3 @@
-import { MouseController } from '../Inputs/MouseController';
 import { VideoPlayer } from './VideoPlayer';
 /**
  * Video Player Controller handles the creation of the video HTML element and all handlers
@@ -6,7 +5,6 @@ import { VideoPlayer } from './VideoPlayer';
 export declare class StreamController {
     videoElementProvider: VideoPlayer;
     audioElement: HTMLAudioElement;
-    mouseController: MouseController;
     /**
      * @param videoElementProvider Video Player instance
      */

package/types/WebRtcPlayer/WebRtcPlayerController.d.ts

@@ -4,7 +4,6 @@ import { FreezeFrameController } from '../FreezeFrame/FreezeFrameController';
 import { AFKController } from '../AFK/AFKController';
 import { DataChannelController } from '../DataChannel/DataChannelController';
 import { PeerConnectionController } from '../PeerConnectionController/PeerConnectionController';
-import { KeyboardController } from '../Inputs/KeyboardController';
 import { AggregatedStats } from '../PeerConnectionController/AggregatedStats';
 import { Config } from '../Config/Config';
 import { FileTemplate } from '../Util/FileUtil';
@@ -14,13 +13,12 @@ import { StreamMessageController, MessageDirection } from '../UeInstanceMessage/
 import { ResponseController } from '../UeInstanceMessage/ResponseController';
 import { SendMessageController } from '../UeInstanceMessage/SendMessageController';
 import { ToStreamerMessagesController } from '../UeInstanceMessage/ToStreamerMessagesController';
-import { MouseController } from '../Inputs/MouseController';
-import { GamePadController } from '../Inputs/GamepadController';
 import { DataChannelSender } from '../DataChannel/DataChannelSender';
-import { CoordinateConverter, UnquantizedDenormalizedUnsignedCoord } from '../Util/CoordinateConverter';
+import { InputCoordTranslator, UntranslatedCoordUnsigned } from '../Util/InputCoordTranslator';
 import { PixelStreaming } from '../PixelStreaming/PixelStreaming';
-import { ITouchController } from '../Inputs/ITouchController';
-import { DataChannelLatencyTestRequest } from "../DataChannel/DataChannelLatencyTestResults";
+import { DataChannelLatencyTestRequest } from '../DataChannel/DataChannelLatencyTestResults';
+import { IInputController } from '../Inputs/IInputController';
+import { GamepadController } from '../Inputs/GamepadController';
 /**
  * Entry point for the WebRTC Player
  */
@@ -41,17 +39,16 @@ export declare class WebRtcPlayerController {
     freezeFrameController: FreezeFrameController;
     shouldShowPlayOverlay: boolean;
     afkController: AFKController;
-    videoElementParentClientRect: DOMRect;
     latencyStartTime: number;
     pixelStreaming: PixelStreaming;
     streamMessageController: StreamMessageController;
     sendMessageController: SendMessageController;
     toStreamerMessagesController: ToStreamerMessagesController;
-    keyboardController: KeyboardController;
-    mouseController: MouseController;
-    touchController: ITouchController;
-    gamePadController: GamePadController;
-    coordinateConverter: CoordinateConverter;
+    keyboardController: IInputController;
+    mouseController: IInputController;
+    touchController: IInputController;
+    gamePadController: GamepadController;
+    coordinateConverter: InputCoordTranslator;
     isUsingSFU: boolean;
     isQualityController: boolean;
     statsTimerHandle: number;
@@ -60,9 +57,10 @@ export declare class WebRtcPlayerController {
     peerConfig: RTCConfiguration;
     videoAvgQp: number;
     locallyClosed: boolean;
-    shouldReconnect: boolean;
-    isReconnecting: boolean;
+    enableAutoReconnect: boolean;
+    forceReconnect: boolean;
     reconnectAttempt: number;
+    isReconnecting: boolean;
     disconnectMessage: string;
     subscribedStream: string;
     signallingUrlBuilder: () => string;
@@ -78,7 +76,7 @@ export declare class WebRtcPlayerController {
      * @param x x axis coordinate
      * @param y y axis coordinate
      */
-    requestUnquantizedAndDenormalizeUnsigned(x: number, y: number): UnquantizedDenormalizedUnsignedCoord;
+    requestUnquantizedAndDenormalizeUnsigned(x: number, y: number): UntranslatedCoordUnsigned;
     /**
      * Handles when a message is received
      * @param event - Message Event
@@ -115,9 +113,13 @@ export declare class WebRtcPlayerController {
      */
     setAfkEnabled(afkEnabled: boolean): void;
     /**
-     * Attempt a reconnection to the signalling server
+     * Attempt a reconnection to the signalling server. Manual trigger
      */
     tryReconnect(message: string): void;
+    /**
+     * Does the actual reconnect work. Used by the auto reconnect feature to skip the manual flag.
+     */
+    doReconnect(message: string): void;
     /**
      * Loads a freeze frame if it is required otherwise shows the play overlay
      */
@@ -230,7 +232,7 @@ export declare class WebRtcPlayerController {
     /**
      * Close the Connection to the signaling server
      */
-    closeSignalingServer(message: string): void;
+    closeSignalingServer(message: string, allowReconnect: boolean): void;
     /**
      * Close the peer connection
      */