@3dsource/angular-unreal-module 0.0.29 → 0.0.31-dev.0

package/index.d.ts

@@ -1,5 +1,1640 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewInit, OnInit, DestroyRef, ElementRef, OnDestroy, PipeTransform } from '@angular/core';
+import { DialogRef } from '@angular/cdk/dialog';
+import * as _3dsource_angular_unreal_module from '@3dsource/angular-unreal-module';
+import * as _ngrx_store from '@ngrx/store';
+import { Store } from '@ngrx/store';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import { MetaBoxCommandList, MetaBoxCommandPacket, FResetControlClampsCommand, FCameraRecenterCommand, FUnLoadAllLevelsCommand, FDragCommand, FUnselectAllProductsCommand, FPauseSequenceCommand, FStopSequenceCommand, FUnLoadAllProductsCommand, FRequestCameraPresetCommand, FLoopBackCommand, FExecuteConsoleCommandCommand, FBoolPayload, FFreezeFrameCommand, FDragSequencePayload, FDragSequenceCommand, FAlignProductsToPlanePayload, FAlignProductsToPlaneCommand, FCameraPresetPayload, FApplyCameraPresetCommand, FLoadSceneStatePayload, FLoadSceneStateCommand, FClickSnapCommand, FControlCameraModePayload, FSetControlCameraModeCommand, FCameraClampsPayload, FSetCameraControlClampsCommand, FSetPawnMovementModePayload, FSetPawnMovementModeCommand, FEnableTeleportCommand, FApplyZoomPayload, FApplyZoomCommand, FFVectorPayload, FCameraBoxCommand, FDropPayload, FDropCommand, FSelectProductByObjectNamePayload, FSelectProductByObjectNameCommand, FGizmoTypePayload, FChangeGizmoTypeCommand, FWeatherPayload, FWeatherCommand, FFitToObjectsPayload, FFitToObjectsCommand, FSetProductsLocationPayload, FSetProductsLocationCommand, FResolutionPayload, FChangeResolutionCommand, FEnableSpinnerModeCommand, FControlSensitivityPayload, FControlSensitivityCommand, FCameraSettingsPayload, FCameraSettingsCommand, FDebugModeCommand, FEnableControlsCommand, FFStringPayload, FInitSequenceByObjectNamePayload, FInitSequenceByObjectNameCommand, FPlaySequencePayload, FPlaySequenceCommand, FJumpToSequencePayload, FJumpToSequenceCommand, FMoveSelectedPayload, FMoveSelectedCommand, FRotatePayload, FRotateSelectedCommand, FRenderPayload, FTakeRenderCommand, FTakeSpinnerRenderPreviewCommand, FTakeSpinnerRenderCommand, FSetMaterialPayload, FSetMaterialCommand, FProductPayload, FLoadProductCommand, FUnLoadProductByObjectNameCommand, FLevelPayload, FLoadLevelCommand, FComposurePayload, FEnableComposureCommand, FFStringsPayload, FClampPanToProductsCommand, FSettingsSequencePayload, FSetSettingsSequenceCommand } from '@3dsource/types-unreal';
+import { ImageOutputValues, IKeyCode } from '@3dsource/utils';
+import { SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
+import * as _ngrx_effects from '@ngrx/effects';
+
+declare class ClickableOverlayComponent {
+    state: i0.Signal<{
+        message: string;
+        className: string;
+        isActivityDetected: boolean;
+        onOverlayClick: () => void;
+    } | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickableOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClickableOverlayComponent, "app-clickable-overlay", never, {}, {}, never, never, true, never>;
+}
+
+declare class FreezeFrameComponent {
+    #private;
+    freezeFrameProgressMessageFromVideo: i0.Signal<number | null | undefined>;
+    combinedFreeze: i0.Signal<string | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FreezeFrameComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FreezeFrameComponent, "app-freeze-frame", never, {}, {}, never, never, true, never>;
+}
+
+declare class LowBandwidthModalComponent {
+    dialogRef: DialogRef<any, any>;
+    close(value?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LowBandwidthModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LowBandwidthModalComponent, "app-low-bandwidth-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class SubService {
+    store: Store<any>;
+    disconnect$: rxjs.Observable<false>;
+}
+
+declare class AFKService extends SubService {
+    private enabled;
+    private closeTimeout;
+    private active;
+    private warnTimer;
+    private countdown;
+    private countdownTimer;
+    private selectWarnTimeout;
+    constructor();
+    initAfk(): void;
+    init(): void;
+    private hideOverlay;
+    /**
+     * Start a timer which when elapsed will warn the user they are inactive.
+     */
+    private startAfkWarningTimer;
+    /**
+     * If the user interacts, then reset the warning timer.
+     */
+    private resetAfkWarningTimer;
+    /**
+     * Update the count-down spans number for the overlay
+     * @param countdown the count down number to be inserted into the span for updating
+     */
+    private updateCountDown;
+    /**
+     * Update the text overlays inner text
+     * @param message the update text to be inserted into the overlay
+     */
+    private dispatchMessage;
+    private stop;
+    private reset;
+    private showAfkOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AFKService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AFKService>;
+}
+
+declare class FreezeFrameService extends SubService {
+    receiving: boolean;
+    private size;
+    private jpeg;
+    private freezeFrameOverlay;
+    init(): void;
+    setData(view: Uint8Array): void;
+    private dispatchInProgress;
+    start(view: Uint8Array): void;
+    invalidate(): void;
+    private showFreezeFrame;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FreezeFrameService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FreezeFrameService>;
+}
+
+declare const WSCloseCode_NORMAL_CLOSURE = 3000;
+declare const WSCloseCode_NORMAL_AFK_TIMEOUT = 3001;
+declare const WSCloseCode_NORMAL_MANUAL_DISCONNECT = 3002;
+declare const WSCloseCode_NORMAL_CIRRUS_CLOSED = 3003;
+declare const WSCloseCodes: readonly [3000, 3001, 3002, 3003];
+type WSCloseCodesValues = (typeof WSCloseCodes)[number];
+
+interface CloseReason {
+    code: WSCloseCodesValues;
+    reason: string;
+}
+
+declare const DisconnectReason: {
+    readonly afk: "afk";
+    readonly none: "none";
+    readonly reset: "reset";
+    readonly wsOnError: "wsOnError";
+    readonly dataChannelClosed: "dataChannelClosed";
+    readonly dataChannelTimeout: "dataChannelTimeout";
+};
+type DisconnectType = (typeof DisconnectReason)[keyof typeof DisconnectReason];
+
+interface UnrealError {
+    errorType: UnrealErrorType;
+    message: string;
+}
+type UnrealErrorType = 'WebRTCError' | 'WebSocketError';
+
+interface FreezeFrameMessage {
+    dataUrl: string | null;
+    progress: number | null;
+}
+
+interface UnrealInitialConfig {
+    customErrorsEndpoint?: string;
+    commandTelemetryReceiver?: string;
+    regionsPingUrl?: string;
+    screenLockerContainerId?: string;
+}
+
+declare const SpecialKeyCodes: {
+    BackSpace: number;
+    Shift: number;
+    Control: number;
+    Alt: number;
+    RightShift: number;
+    RightControl: number;
+    RightAlt: number;
+};
+declare const MouseButton: {
+    MainButton: number;
+    AuxiliaryButton: number;
+    SecondaryButton: number;
+    FourthButton: number;
+    FifthButton: number;
+};
+declare const MouseButtonsMask: {
+    PrimaryButton: number;
+    SecondaryButton: number;
+    AuxiliaryButton: number;
+    FourthButton: number;
+    FifthButton: number;
+};
+
+declare const EControlSchemeType: {
+    readonly LockedMouse: 0;
+    readonly HoveringMouse: 1;
+    readonly Default: 2;
+};
+type EControlSchemeTypeValues = (typeof EControlSchemeType)[keyof typeof EControlSchemeType];
+
+declare const EMessageType: {
+    readonly IFrameRequest: 0;
+    readonly RequestQualityControl: 1;
+    readonly MaxFpsRequest: 2;
+    readonly AverageBitrateRequest: 3;
+    readonly StartStreaming: 4;
+    readonly StopStreaming: 5;
+    readonly LatencyTest: 6;
+    readonly RequestInitialSettings: 7;
+    readonly UIInteraction: 50;
+    readonly Command: 51;
+    readonly KeyDown: 60;
+    readonly KeyUp: 61;
+    readonly KeyPress: 62;
+    readonly MouseEnter: 70;
+    readonly MouseLeave: 71;
+    readonly MouseDown: 72;
+    readonly MouseUp: 73;
+    readonly MouseMove: 74;
+    readonly MouseWheel: 75;
+    readonly TouchStart: 80;
+    readonly TouchEnd: 81;
+    readonly TouchMove: 82;
+};
+type EMessageTypeValues = (typeof EMessageType)[keyof typeof EMessageType];
+
+declare const EToClientMessageType: {
+    readonly QualityControlOwnership: 0;
+    readonly Response: 1;
+    readonly Command: 2;
+    readonly FreezeFrame: 3;
+    readonly UnfreezeFrame: 4;
+    readonly VideoEncoderAvgQP: 5;
+    readonly LatencyTest: 6;
+    readonly InitialSettings: 7;
+    readonly InputControlOwnership: 12;
+    readonly Protocol: 255;
+};
+
+declare const UNREAL_CONFIG: InjectionToken<UnrealInitialConfig>;
+
+declare const InputOptions: InputProps;
+
+declare const UnrealStatusMessage: {
+    readonly CONNECTING_TO_SESSION: "Connecting to session.";
+    readonly STARTING_YOUR_SESSION: "Starting your session";
+};
+
+declare const DEBOUNCE_TO_MANY_RESIZE_CALLS = 100;
+declare const SAME_SIZE_THRESHOLD = 1.01;
+declare const MINIMAL_FPS = 6;
+declare const STREAMING_VIDEO_ID = "streamingVideo";
+declare const CONSOLE_COMMAND_ENABLE_MESSAGES = "EnableAllScreenMessages";
+declare const CONSOLE_COMMAND_DISABLE_MESSAGES = "DisableAllScreenMessages";
+declare const CONSOLE_COMMAND_PIXEL_QUALITY = "PixelStreaming.FreezeFrameQuality 95";
+declare const FULL_HD_WIDTH = 1920;
+declare const FULL_HD_HEIGHT = 1080;
+declare const WS_TIMEOUT = 2000;
+declare const WS_OPEN_STATE = 1;
+declare const DEFAULT_TIMEOUT_PERIOD = 15;
+declare const DEFAULT_WARN_TIMEOUT = 120;
+declare const DATA_CHANNEL_CONNECTION_TIMEOUT = 5000;
+declare const SCREEN_LOCKER_CONTAINER_ID = "3dsource_start_screen";
+
+interface NormalizeAndQuantizeUnsignedValue {
+    inRange: boolean;
+    x: number;
+    y: number;
+}
+interface UnquantizeAndDenormalizeUnsignedValue {
+    x: number;
+    y: number;
+}
+interface NormalizeAndQuantizeSignedValue {
+    x: number;
+    y: number;
+}
+interface InputProps {
+    controlScheme: EControlSchemeTypeValues;
+    suppressBrowserKeys: boolean;
+    fakeMouseWithTouches: boolean;
+}
+
+declare function AnswerHandler(this: SignallingService, msg: AnswerMessage): void;
+
+declare function ConfigHandler(this: SignallingService, msg: ConfigMessage): void;
+
+declare function IceCandidateHandler(this: SignallingService, msg: {
+    candidate: RTCIceCandidate;
+}): void;
+
+declare function InstanceReadyHandler(this: SignallingService, _: InstanceReady): void;
+
+declare function InstanceReservedHandler(this: SignallingService, msg: InstanceReserved): void;
+
+declare function PingHandler(this: SignallingService): void;
+
+declare function PlayerCountHandler(this: SignallingService, msg: PlayerCountMessage): void;
+
+declare function SSInfoHandler(this: SignallingService, msg: SSInfo): null;
+
+declare function OnCloseHandler(this: SignallingService, e: CloseEvent): void;
+
+declare function OnErrorHandler(this: SignallingService, e: Event): void;
+
+declare function OnMessageHandler(this: SignallingService, e: MessageEvent<string>): void;
+
+declare function OnOpenHandler(this: SignallingService): void;
+
+declare const clampAndKeepMaxPercents: () => ((source: Observable<number>) => Observable<number>);
+
+declare function observeCommandResponse<K extends keyof MetaBoxCommandList, T extends MetaBoxCommandList[K] = MetaBoxCommandList[K]>(data: T, sender: (data: T) => void, timeOut?: number, dispatchOnTimeout?: boolean): Observable<ObservedCallbackResponse<T> | never>;
+interface ObservedCallbackResponse<T extends MetaBoxCommandPacket> {
+    json: {
+        commandCallback: T;
+    };
+}
+
+declare function decodeData(anyData: any): string;
+
+interface FilterSettings {
+    /**
+     * Minimum number of kilobits per second to trigger low bandwidth
+     */
+    minimumBitrate: number;
+    /**
+     * Amount of a percentage drop to trigger a yellow warning
+     */
+    yellowFlag: number;
+    /**
+     * Amount of a percentage drop to trigger a red warning
+     */
+    redFlag: number;
+    /**
+     * Minimum number of frames per second to trigger low bandwidth
+     */
+    minimumFps: number;
+    /**
+     * Time to wait before checking if we can switch to low bandwidth
+     */
+    monitoringDelayTime: number;
+    initialBitrateEstimate: number;
+    initialErrorCovariance: number;
+    processNoise: number;
+    measurementNoise: number;
+    panelOpen: boolean;
+}
 /**
- * Generated bundle index. Do not edit.
+ * Default LBM Filter Parameters
  */
-/// <amd-module name="@3dsource/angular-unreal-module" />
-export * from './public-api';
+declare const DefaultFilterModel: FilterSettings;
+
+interface DataFlowCheckResult {
+    isDropDetected: boolean;
+    dropPercentage: number;
+    activeMedian: number;
+    quality: Quality;
+    message: string;
+    dataHistory: number[];
+    config: {
+        yellowFlagThresholdPercentage: number;
+        redFlagThresholdPercentage: number;
+        historyBufferLength: number;
+        splitPoint: number;
+    };
+}
+declare class DataFlowMonitor {
+    protected yellowFlagThresholdPercentage: number;
+    protected redFlagThresholdPercentage: number;
+    protected historyBufferLength: number;
+    protected splitPoint: number;
+    protected dataHistory: number[];
+    /**
+     * Initializes the DataFlowMonitor monitor.
+     * @param yellowFlagThresholdPercentage - The percentage drop to trigger a YELLOW warning (default: 15%).
+     * @param redFlagThresholdPercentage - The percentage drop to trigger a RED warning (default: 30%).
+     * @param historyBufferLength - buffer length (default: 100).
+     * @param splitPoint - The point at which to split the history buffer into two halves (default: 0.5).
+     */
+    constructor(yellowFlagThresholdPercentage?: number, redFlagThresholdPercentage?: number, historyBufferLength?: number, splitPoint?: number);
+    reset(): void;
+    config(data: FilterSettings): void;
+    /**
+     * Adds a new bitrate measurement and checks for significant drops.
+     * @param currentValue - The current bitrate in kbps.
+     * @returns BitrateCheckResult indicating if a drop was detected.
+     */
+    addValue(currentValue: number): DataFlowCheckResult;
+}
+
+declare const dispatchResize: () => void;
+declare const forceResizeUnrealVideo: () => void;
+
+declare function getRtcErrorMessage(code: number | null): string | undefined;
+
+type Descriptor = MetaBoxCommandList & SignalDescriptor;
+/**
+ * UnrealInternalSignalEvents commands list wrapper listener
+ * @param event
+ */
+declare function fromSignal<K extends keyof Descriptor>(event: K): Observable<Descriptor[K]>;
+type ArgumentType<K extends keyof Descriptor> = Descriptor[K] extends void ? never : Descriptor[K];
+/**
+ * UnrealInternalSignalEvents commands list wrapper sender
+ * @param event
+ * @param args
+ */
+declare function sendSignal<K extends keyof Descriptor>(event: K, ...args: ArgumentType<K> extends never ? [] : [ArgumentType<K>]): void;
+declare function fromUnrealCallBackSignal<K extends keyof Descriptor>(command: K): Observable<Descriptor[K]>;
+
+declare const floatToSmoothPercents: () => ((source: Observable<number>) => Observable<number>);
+
+declare const getImageFromVideoStream: (takeSizeFrom?: "video" | "constant", imageOutput?: ImageOutputValues, sizes?: StreamResolutionProps) => string | null;
+
+declare function getActiveUrl(urls: string[]): Generator<string, void, unknown>;
+
+declare class KalmanFilter1D {
+    private estimate;
+    private uncertainty;
+    private processNoise;
+    private measurementNoise;
+    /**
+     * @param initialEstimate Initial guess of the state.
+     * @param initialUncertainty Initial uncertainty in the guess.
+     * @param processNoise Process variance (Q) representing model uncertainty.
+     * @param measurementNoise Measurement variance (R) representing noise in measurements.
+     */
+    constructor(initialEstimate: number, initialUncertainty: number, processNoise: number, measurementNoise: number);
+    /**
+     * Incorporates a new measurement and returns the updated estimate.
+     * @param measurement The new measurement value.
+     */
+    update(measurement: number): number;
+    config(data: FilterSettings): void;
+}
+
+declare class LatencyTimings {
+    TestStartTimeMs: number | null;
+    UEReceiptTimeMs: number | null;
+    UEEncodeMs: number | null;
+    UECaptureToSendMs: number | null;
+    UETransmissionTimeMs: number | null;
+    BrowserReceiptTimeMs: number | null;
+    FrameDisplayDeltaTimeMs: number | null;
+    Reset(): void;
+    SetUETimings(UETimings: any): void;
+    SetFrameDisplayDeltaTime(DeltaTimeMs: number): void;
+    OnAllLatencyTimingsReady(_: any): void;
+}
+
+declare function mapQpToQuality(VideoEncoderQP: number): Quality;
+
+declare const getResetControlClampsCommand: () => FResetControlClampsCommand;
+declare const getCameraRecenterCommand: () => FCameraRecenterCommand;
+declare const unLoadAllLevelsCommand: () => FUnLoadAllLevelsCommand;
+declare const getDragCommand: () => FDragCommand;
+declare const getUnselectAllProductsCommand: () => FUnselectAllProductsCommand;
+declare const getPauseSequenceCommand: () => FPauseSequenceCommand;
+declare const getStopSequenceCommand: () => FStopSequenceCommand;
+declare const getUnLoadAllProductsCommand: () => FUnLoadAllProductsCommand;
+declare const getRequestCameraPresetCommand: () => FRequestCameraPresetCommand;
+declare const getLoopBackCommand: () => FLoopBackCommand;
+declare const getSetFpsCommand: (fpsRequired: number) => FExecuteConsoleCommandCommand;
+declare const getFreezeFrameCommand: (payload: FBoolPayload, source: string) => FFreezeFrameCommand;
+declare const getDragSequenceCommand: (payload: FDragSequencePayload) => FDragSequenceCommand;
+declare const alignProductsToPlaneCommand: (payload: FAlignProductsToPlanePayload) => FAlignProductsToPlaneCommand;
+declare const getApplyCameraPresetCommand: (payload: FCameraPresetPayload) => FApplyCameraPresetCommand;
+declare const getLoadSceneStateCommand: (payload: FLoadSceneStatePayload) => FLoadSceneStateCommand;
+declare const getClickSnapCommand: (payload: FBoolPayload) => FClickSnapCommand;
+declare const getSetControlCameraModeCommand: (payload: FControlCameraModePayload) => FSetControlCameraModeCommand;
+declare const getSetCameraControlClampsCommand: (payload: FCameraClampsPayload) => FSetCameraControlClampsCommand;
+declare const getSetPawnMovementModeCommand: (payload: FSetPawnMovementModePayload) => FSetPawnMovementModeCommand;
+declare const getEnableTeleportCommand: (payload: FBoolPayload) => FEnableTeleportCommand;
+declare const getApplyZoomCommand: (payload: FApplyZoomPayload) => FApplyZoomCommand;
+declare const getCameraBoxCommand: (payload: FFVectorPayload) => FCameraBoxCommand;
+declare const getDropCommand: (payload?: FDropPayload) => FDropCommand;
+declare const getSelectProductByObjectNameCommand: (payload: FSelectProductByObjectNamePayload) => FSelectProductByObjectNameCommand;
+declare const getChangeGizmoTypeCommand: (payload: FGizmoTypePayload) => FChangeGizmoTypeCommand;
+declare const getWeatherCommand: (payload: FWeatherPayload) => FWeatherCommand;
+declare const getFitToObjectsCommand: (payload?: FFitToObjectsPayload) => FFitToObjectsCommand;
+declare const setProductsLocationCommand: (payload: FSetProductsLocationPayload) => FSetProductsLocationCommand;
+declare const getChangeResolutionCommand: (payload: FResolutionPayload) => FChangeResolutionCommand;
+declare const getEnableSpinnerModeCommand: (payload: FBoolPayload) => FEnableSpinnerModeCommand;
+declare const getControlSensitivityCommand: (payload: FControlSensitivityPayload) => FControlSensitivityCommand;
+declare const getCameraSettingsCommand: (payload: FCameraSettingsPayload) => FCameraSettingsCommand;
+declare const getDebugModeCommand: (payload: FBoolPayload) => FDebugModeCommand;
+declare const getEnableControlsCommand: (payload: FBoolPayload) => FEnableControlsCommand;
+declare const getExecuteConsoleCommand: (payload: FFStringPayload) => FExecuteConsoleCommandCommand;
+declare const getInitSequenceByObjectNameCommand: (payload: FInitSequenceByObjectNamePayload) => FInitSequenceByObjectNameCommand;
+declare const getPlaySequenceCommand: (payload: FPlaySequencePayload) => FPlaySequenceCommand;
+declare const getJumpToSequenceCommand: (payload: FJumpToSequencePayload) => FJumpToSequenceCommand;
+declare const getMoveSelectedCommand: (payload: FMoveSelectedPayload) => FMoveSelectedCommand;
+declare const getRotateSelectedCommand: (payload: FRotatePayload) => FRotateSelectedCommand;
+declare const getTakeRenderCommand: (payload: FRenderPayload) => FTakeRenderCommand;
+declare const getTakeSpinnerRenderPreviewCommand: (payload: FRenderPayload) => FTakeSpinnerRenderPreviewCommand;
+declare const getTakeSpinnerRenderCommand: (payload: FRenderPayload) => FTakeSpinnerRenderCommand;
+declare const getSetMaterialCommand: (payload: FSetMaterialPayload) => FSetMaterialCommand;
+declare const getLoadProductCommand: (payload: FProductPayload) => FLoadProductCommand;
+declare const getUnLoadProductByObjectNameCommand: (payload: FFStringPayload) => FUnLoadProductByObjectNameCommand;
+declare const getLoadLevelCommand: (payload: FLevelPayload) => FLoadLevelCommand;
+declare const getEnableComposureCommand: (payload: FComposurePayload) => FEnableComposureCommand;
+declare const clampPanToProductsCommand: (payload?: FFStringsPayload) => FClampPanToProductsCommand;
+declare const getSetSettingsSequenceCommand: (payload: FSettingsSequencePayload) => FSetSettingsSequenceCommand;
+
+declare const trackMixpanelEvent: _ngrx_store.ActionCreator<string, (props: {
+    event: string;
+    data?: unknown;
+}) => {
+    event: string;
+    data?: unknown;
+} & _ngrx_store.Action<string>>;
+declare const changeLowBandwidth: _ngrx_store.ActionCreator<string, (props: {
+    lowBandwidth: boolean;
+    stats?: LBMStats;
+}) => {
+    lowBandwidth: boolean;
+    stats?: LBMStats;
+} & _ngrx_store.Action<string>>;
+declare const setMaxFps: _ngrx_store.ActionCreator<string, (props: {
+    maxFps: number;
+}) => {
+    maxFps: number;
+} & _ngrx_store.Action<string>>;
+declare const destroyRemoteConnections: _ngrx_store.ActionCreator<string, (props: {
+    disconnectReason: DisconnectType;
+}) => {
+    disconnectReason: DisconnectType;
+} & _ngrx_store.Action<string>>;
+declare const destroyConnectionsAndResetState: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const setCirrusConnected: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const setCirrusDisconnected: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const changeStatusMainVideoOnScene: _ngrx_store.ActionCreator<string, (props: {
+    isVideoPlaying: boolean;
+}) => {
+    isVideoPlaying: boolean;
+} & _ngrx_store.Action<string>>;
+declare const setAwsInstance: _ngrx_store.ActionCreator<string, (props: {
+    wsUrl: string | null;
+    pollingUrl: string | null;
+    instanceName: string | null;
+}) => {
+    wsUrl: string | null;
+    pollingUrl: string | null;
+    instanceName: string | null;
+} & _ngrx_store.Action<string>>;
+declare const setStatusMessage: _ngrx_store.ActionCreator<string, (props: {
+    message: string | null;
+}) => {
+    message: string | null;
+} & _ngrx_store.Action<string>>;
+declare const setStatusPercentSignallingServer: _ngrx_store.ActionCreator<string, (props: {
+    percent: number | null;
+}) => {
+    percent: number | null;
+} & _ngrx_store.Action<string>>;
+declare const setFreezeFrame: _ngrx_store.ActionCreator<string, (props: {
+    dataUrl: string | null;
+    progress: number | null;
+}) => {
+    dataUrl: string | null;
+    progress: number | null;
+} & _ngrx_store.Action<string>>;
+declare const setMatchUrls: _ngrx_store.ActionCreator<string, (props: {
+    urls: string[];
+}) => {
+    urls: string[];
+} & _ngrx_store.Action<string>>;
+declare const setStreamClientCompanyId: _ngrx_store.ActionCreator<string, (props: {
+    id: string;
+}) => {
+    id: string;
+} & _ngrx_store.Action<string>>;
+declare const setStreamViewId: _ngrx_store.ActionCreator<string, (props: {
+    id: string;
+}) => {
+    id: string;
+} & _ngrx_store.Action<string>>;
+declare const setIntroImageSrc: _ngrx_store.ActionCreator<string, (props: {
+    src: string;
+}) => {
+    src: string;
+} & _ngrx_store.Action<string>>;
+declare const setLoadingImageSrc: _ngrx_store.ActionCreator<string, (props: {
+    src: string;
+}) => {
+    src: string;
+} & _ngrx_store.Action<string>>;
+declare const setIntroVideoSrc: _ngrx_store.ActionCreator<string, (props: {
+    src: string;
+}) => {
+    src: string;
+} & _ngrx_store.Action<string>>;
+declare const resetIntroSrc: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const setFreezeFrameFromVideo: _ngrx_store.ActionCreator<string, (props: {
+    dataUrl: string | null;
+    progress: number | null;
+}) => {
+    dataUrl: string | null;
+    progress: number | null;
+} & _ngrx_store.Action<string>>;
+declare const setEstablishingConnection: _ngrx_store.ActionCreator<string, (props: {
+    value: boolean;
+}) => {
+    value: boolean;
+} & _ngrx_store.Action<string>>;
+declare const setDataChannelConnected: _ngrx_store.ActionCreator<string, (props: {
+    value: boolean;
+}) => {
+    value: boolean;
+} & _ngrx_store.Action<string>>;
+declare const setConfig: _ngrx_store.ActionCreator<string, (props: {
+    config: Partial<StreamConfig>;
+}) => {
+    config: Partial<StreamConfig>;
+} & _ngrx_store.Action<string>>;
+declare const setErrorMessage: _ngrx_store.ActionCreator<string, (props: {
+    errorType: UnrealErrorType;
+    message: string;
+}) => {
+    errorType: UnrealErrorType;
+    message: string;
+} & _ngrx_store.Action<string>>;
+declare const setViewportReady: _ngrx_store.ActionCreator<string, (props: {
+    value: boolean;
+}) => {
+    value: boolean;
+} & _ngrx_store.Action<string>>;
+declare const changeStreamResolutionAction: _ngrx_store.ActionCreator<string, (props: {
+    width: number | null;
+    height: number | null;
+}) => {
+    width: number | null;
+    height: number | null;
+} & _ngrx_store.Action<string>>;
+declare const changeStreamResolutionSuccessAction: _ngrx_store.ActionCreator<string, (props: {
+    width: number | null;
+    height: number | null;
+}) => {
+    width: number | null;
+    height: number | null;
+} & _ngrx_store.Action<string>>;
+declare const setSignalingName: _ngrx_store.ActionCreator<string, (props: {
+    instanceName: string;
+}) => {
+    instanceName: string;
+} & _ngrx_store.Action<string>>;
+declare const updateCirrusInfo: _ngrx_store.ActionCreator<string, (props: {
+    ssInfo: string;
+    ssData: SignalingData;
+}) => {
+    ssInfo: string;
+    ssData: SignalingData;
+} & _ngrx_store.Action<string>>;
+declare const commandStarted: _ngrx_store.ActionCreator<string, (props: {
+    id: string;
+    command: string;
+}) => {
+    id: string;
+    command: string;
+} & _ngrx_store.Action<string>>;
+declare const commandCompleted: _ngrx_store.ActionCreator<string, (props: {
+    id: string;
+}) => {
+    id: string;
+} & _ngrx_store.Action<string>>;
+declare const setLoopBackCommandIsCompleted: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const showUnrealErrorMessage: _ngrx_store.ActionCreator<string, (props: {
+    code: number | null;
+    error?: string;
+}) => {
+    code: number | null;
+    error?: string;
+} & _ngrx_store.Action<string>>;
+declare const initSignalling: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const resetConfig: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const resetAfkAction: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const resetWarnTimeout: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const resetUnrealStateAction: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+declare const resetUnrealState: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
+
+declare class UnrealEffects {
+    private dialog;
+    private http;
+    private store;
+    private isDevMode;
+    private unrealInitialConfig;
+    private actions$;
+    private player;
+    private signallingService;
+    private scrollStrategy;
+    private commandsSender;
+    private videoStatGenerator;
+    cirrusDisconnectEffect$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    destroyConnections$: rxjs.Observable<{
+        disconnectReason: _3dsource_angular_unreal_module.DisconnectType;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    resetState$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    destroyRemoteConnections$: rxjs.Observable<{
+        disconnectReason: _3dsource_angular_unreal_module.DisconnectType;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    changeStreamResolution$: rxjs.Observable<{
+        width: number | null;
+        height: number | null;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    forceLBMOff$: rxjs.Observable<{
+        lowBandwidth: boolean;
+        stats?: _3dsource_angular_unreal_module.LBMStats;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    resetFreezeFrameOnLowBandwidthTriggered$: rxjs.Observable<{
+        dataUrl: string | null;
+        progress: number | null;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    sendLbmStat$: rxjs.Subscription;
+    resetAfk$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    resetFreezeFrameOnViewportDestroy$: rxjs.Observable<{
+        dataUrl: string | null;
+        progress: number | null;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    setMaxFps$: rxjs.Observable<{
+        maxFps: number;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    webrtcErrorModalComponent$: rxjs.Observable<[arg: {
+        errorType: _3dsource_angular_unreal_module.UnrealErrorType;
+        message: string;
+    } & _ngrx_store.Action<string>, boolean]> & _ngrx_effects.CreateEffectMetadata;
+    resetAfkAction$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    setDataChannelTimeoutCheck$: rxjs.Observable<{
+        disconnectReason: _3dsource_angular_unreal_module.DisconnectType;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    destroyConnectionAndRestart$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    showUnrealError$: rxjs.Observable<{
+        code: number | null;
+        error?: string;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    sendStatisticsToUnreal$: rxjs.Observable<void> & _ngrx_effects.CreateEffectMetadata;
+    initAppBySetDataChannelConnected$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    setViewportReadyBySetLoopBackCommandIsCompleted$: rxjs.Observable<{
+        value: boolean;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    listenUnrealCallbackByInitSignalling$: rxjs.Observable<{
+        id: string;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    setConfigByInitSignalling$: rxjs.Observable<{
+        config: Partial<_3dsource_angular_unreal_module.StreamConfig>;
+    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnrealEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnrealEffects>;
+}
+
+declare const unrealFeature: {
+    name: "unrealFeature";
+    reducer: _ngrx_store.ActionReducer<_3dsource_angular_unreal_module.UnrealState, _ngrx_store.Action<string>>;
+    selectUnrealFeatureState: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.UnrealState, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.UnrealState>;
+    selectLowBandwidth: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectDisconnectReason: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.DisconnectType, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.DisconnectType>;
+    selectIsVideoPlaying: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectSsInfo: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
+    selectSsData: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.SignalingData | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.SignalingData | null>;
+    selectLowBandwidthStats: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.LBMStats | undefined, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.LBMStats | undefined>;
+    selectStreamConfig: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.StreamConfig, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.StreamConfig>;
+    selectAwsInstance: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.AwsInstance, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.AwsInstance>;
+    selectWasInitialized: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectIsFirstSuccessLoad: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectCirrusConnected: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectViewportReady: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectFreezeFrameFromVideo: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.FreezeFrameMessage, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.FreezeFrameMessage>;
+    selectFreezeFrame: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.FreezeFrameMessage, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.FreezeFrameMessage>;
+    selectStatusMessage: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
+    selectStatusPercentSignallingServer: _ngrx_store.MemoizedSelector<Record<string, any>, number | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => number | null>;
+    selectErrorMessage: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.UnrealError | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.UnrealError | null>;
+    selectDataChannelConnected: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectStreamResolution: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.StreamResolutionProps, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.StreamResolutionProps>;
+    selectEstablishingConnection: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
+    selectLoaderCommands: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.CommandsLoaderState, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.CommandsLoaderState>;
+    selectMatchUrls: _ngrx_store.MemoizedSelector<Record<string, any>, string[], (featureState: _3dsource_angular_unreal_module.UnrealState) => string[]>;
+    selectStreamClientCompanyId: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
+    selectStreamViewId: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
+    selectVideoIntroSrc: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
+    selectImageIntroSrc: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
+    selectImageLoadingSrc: _ngrx_store.MemoizedSelector<Record<string, any>, string, (featureState: _3dsource_angular_unreal_module.UnrealState) => string>;
+};
+
+interface CommandsLoaderState {
+    commandsInProgress: {
+        timeStamp: number;
+        command: string;
+        id: string;
+    }[];
+    totalCommandsStarted: number;
+    totalCommandsCompleted: number;
+}
+interface UnrealState {
+    lowBandwidthStats: LBMStats | undefined;
+    streamConfig: StreamConfig;
+    awsInstance: AwsInstance;
+    lowBandwidth: boolean;
+    wasInitialized: boolean;
+    isFirstSuccessLoad: boolean;
+    cirrusConnected: boolean;
+    viewportReady: boolean;
+    freezeFrameFromVideo: FreezeFrameMessage;
+    freezeFrame: FreezeFrameMessage;
+    statusMessage: string | null;
+    /**
+     * @deprecated, use ssData in future
+     */
+    ssInfo: string | null;
+    ssData: SignalingData | null;
+    statusPercentSignallingServer: number | null;
+    errorMessage: UnrealError | null;
+    dataChannelConnected: boolean;
+    streamResolution: StreamResolutionProps;
+    isVideoPlaying: boolean;
+    establishingConnection: boolean;
+    disconnectReason: DisconnectType;
+    loaderCommands: CommandsLoaderState;
+    matchUrls: string[];
+    streamClientCompanyId: string | null;
+    streamViewId: string | null;
+    videoIntroSrc: string | null;
+    imageIntroSrc: string | null;
+    imageLoadingSrc: string;
+}
+declare const initialState: UnrealState;
+declare const unrealReducer: _ngrx_store.ActionReducer<UnrealState, _ngrx_store.Action<string>>;
+
+declare const selectFreezeFrameDataUrlFromVideo: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (s1: _3dsource_angular_unreal_module.FreezeFrameMessage, s2: boolean) => string | null>;
+declare const selectFreezeFrameProgressMessageFromVideo: _ngrx_store.MemoizedSelector<Record<string, any>, number | null, (s1: _3dsource_angular_unreal_module.FreezeFrameMessage, s2: boolean) => number | null>;
+declare const selectFreezeFrameDataUrl: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (s1: _3dsource_angular_unreal_module.FreezeFrameMessage, s2: boolean) => string | null>;
+declare const selectIsFreezeFrameLoading: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: _3dsource_angular_unreal_module.FreezeFrameMessage) => boolean>;
+declare const selectFreezeFrameCombinedDataUrl: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (s1: string | null, s2: string | null) => string | null>;
+declare const selectStreamConfig: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.StreamConfig, (s1: _3dsource_angular_unreal_module.StreamConfig) => _3dsource_angular_unreal_module.StreamConfig>;
+declare const selectWarnTimeout: _ngrx_store.MemoizedSelector<Record<string, any>, number, (s1: _3dsource_angular_unreal_module.StreamConfig) => number>;
+declare const selectMatchUrls: _ngrx_store.MemoizedSelector<Record<string, any>, string[], (s1: _3dsource_angular_unreal_module.StreamConfig) => string[]>;
+declare const selectIsAutostart: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: _3dsource_angular_unreal_module.StreamConfig) => boolean>;
+declare const selectWsUrl: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (s1: _3dsource_angular_unreal_module.AwsInstance) => string | null>;
+declare const selectShowReconnectPopup: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: boolean, s2: boolean, s3: boolean, s4: string | null, s5: string | null) => boolean>;
+declare const selectShowLoader: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: boolean, s2: boolean, s3: _3dsource_angular_unreal_module.StreamConfig, s4: boolean) => boolean>;
+declare const selectIsVideoPlayingAndDataChannelConnected: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: boolean, s2: boolean) => boolean>;
+declare const selectSignalingParameters: _ngrx_store.MemoizedSelector<Record<string, any>, string, (s1: _3dsource_angular_unreal_module.SignalingData | null, s2: _3dsource_angular_unreal_module.AwsInstance, s3: string | null) => string>;
+declare const selectLoaderCommands: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.CommandsLoaderState, (s1: _3dsource_angular_unreal_module.CommandsLoaderState) => _3dsource_angular_unreal_module.CommandsLoaderState>;
+declare const selectCommandsInProgress: _ngrx_store.MemoizedSelector<Record<string, any>, number, (s1: _3dsource_angular_unreal_module.CommandsLoaderState) => number>;
+declare const selectCommandProgress: _ngrx_store.MemoizedSelector<Record<string, any>, number, (s1: _3dsource_angular_unreal_module.CommandsLoaderState) => number>;
+declare const selectLastCommandInProgress: _ngrx_store.MemoizedSelector<Record<string, any>, {
+    timeStamp: number;
+    command: string;
+    id: string;
+} | null, (s1: _3dsource_angular_unreal_module.CommandsLoaderState) => {
+    timeStamp: number;
+    command: string;
+    id: string;
+} | null>;
+/**
+ * Returns Scene load progress as a float value in between 0-1
+ */
+declare const selectTotalProgress: _ngrx_store.MemoizedSelector<Record<string, any>, number, (s1: number | null, s2: number, s3: _3dsource_angular_unreal_module.AwsInstance) => number>;
+
+declare const removeExileCommands: (state: CommandsLoaderState, idToRemove: string) => {
+    commandsInProgress: {
+        timeStamp: number;
+        command: string;
+        id: string;
+    }[];
+    totalCommandsStarted: number;
+    totalCommandsCompleted: number;
+};
+
+declare const resetAfk: () => void;
+
+declare function fromResizeObserver(elem: HTMLElement): Observable<ResizeObserverEntry[]>;
+
+declare class VideoRecorder {
+    private recordedChunks;
+    private mediaRecorder;
+    capture(canvas: any): void;
+    stop(): void;
+    handleDataAvailable(event: any): void;
+    download(): void;
+}
+
+interface LBMStats {
+    dataFlowResult: DataFlowCheckResult;
+    reason: string;
+    triggerTime: number;
+}
+
+type Quality = 'lime' | 'red' | 'orange';
+
+interface SignalingData {
+    branchInfo: string;
+    cirrusVersion: string;
+    streamerVersion: string;
+    streamPath: string;
+    streamApp: string;
+    connectionId: string;
+}
+
+interface InstanceReady extends InstanceMessageBase {
+    type: 'instanceReady';
+}
+interface InstanceReserved extends InstanceMessageBase {
+    type: 'instanceReserved';
+}
+interface InstanceMessageBase extends MessageBase {
+    correlationId: string;
+    payload: {
+        instanceId: string;
+    };
+}
+interface MessageBase {
+    type: OrchestrationMessageType;
+}
+interface SSInfo extends MessageBase {
+    type: 'ssInfo';
+    message: string;
+    data: SignalingData;
+}
+interface PlayerCountMessage extends MessageBase {
+    type: 'playerCount';
+    playerCount: number;
+}
+interface AnswerMessage extends RTCSessionDescriptionInit {
+    type: RTCSdpType;
+}
+interface ConfigMessage extends MessageBase, UnknownFields {
+    type: 'config';
+    peerConnectionOptions: RTCConfiguration;
+}
+interface CandidateMessage extends MessageBase {
+    type: 'iceCandidate';
+    candidate: RTCIceCandidate;
+}
+interface PingMessage extends MessageBase {
+    type: 'ping';
+    playerId: string;
+    appConnectionCounter: number;
+}
+type UnknownFields = Record<string, unknown>;
+declare const OrchestrationMessageTypes: {
+    readonly requestReservation: "requestReservation";
+    readonly instanceReady: "instanceReady";
+    readonly instanceReserved: "instanceReserved";
+    readonly ssInfo: "ssInfo";
+    readonly playerCount: "playerCount";
+    readonly answer: "answer";
+    readonly iceCandidate: "iceCandidate";
+    readonly ping: "ping";
+    readonly config: "config";
+};
+interface SignalingMessageMap {
+    [OrchestrationMessageTypes.ssInfo]: SSInfo;
+    [OrchestrationMessageTypes.playerCount]: PlayerCountMessage;
+    [OrchestrationMessageTypes.answer]: AnswerMessage;
+    [OrchestrationMessageTypes.config]: ConfigMessage;
+    [OrchestrationMessageTypes.iceCandidate]: CandidateMessage;
+    [OrchestrationMessageTypes.instanceReady]: InstanceReady;
+    [OrchestrationMessageTypes.instanceReserved]: InstanceReserved;
+    [OrchestrationMessageTypes.ping]: PingMessage;
+}
+type OrchestrationMessageType = keyof SignalingMessageMap;
+type SignalingMessageHandler<T extends keyof SignalingMessageMap> = (msg: SignalingMessageMap[T]) => void;
+interface PollingOrchestrationMessage {
+    mm_message?: string;
+    signallingServer?: string;
+    error?: string;
+    info?: {
+        age: number | null;
+        left: number | null;
+        percent: number | null;
+        total: number | null;
+    };
+}
+
+interface StreamConfig {
+    autoStart: boolean;
+    warnTimeout: number;
+    matchMakerUrls: string[];
+}
+
+interface StreamResolutionProps {
+    width: number | null;
+    height: number | null;
+}
+
+type TelemetryType = 'commandSent' | 'commandStop';
+
+declare const UnrealInternalSignalEvents: {
+    readonly OnVideoInitialized: "OnVideoInitialized";
+    readonly RestAfkTimer: "RestAfkTimer";
+    readonly FreezeFrameStart: "FreezeFrameStart";
+    readonly UnrealCallback: "UnrealCallback";
+    readonly ClickableOverlay: "ClickableOverlay";
+    readonly VideoPlayClick: "VideoPlayClick";
+    readonly ShowPlayButton: "ShowPlayButton";
+    readonly ForceResizeViewport: "ForceResizeViewport";
+    readonly VideoAdaptedToContainer: "VideoAdaptedToContainer";
+    readonly TelemetryStart: "TelemetryStart";
+    readonly TelemetryStop: "TelemetryStop";
+    readonly TelemetryReset: "TelemetryReset";
+};
+interface SignalDescriptor {
+    [UnrealInternalSignalEvents.UnrealCallback]: {
+        json: UnrealCallBackJson;
+    };
+    [UnrealInternalSignalEvents.ClickableOverlay]: {
+        message: string;
+        className: string;
+        isActivityDetected: boolean;
+        onOverlayClick: () => void;
+    } | void;
+    [UnrealInternalSignalEvents.VideoPlayClick]: {
+        text: string;
+    };
+    [UnrealInternalSignalEvents.ForceResizeViewport]: void;
+    [UnrealInternalSignalEvents.OnVideoInitialized]: HTMLVideoElement;
+    [UnrealInternalSignalEvents.VideoAdaptedToContainer]: void;
+    [UnrealInternalSignalEvents.ShowPlayButton]: {
+        text: string;
+        callback: () => boolean;
+    };
+    [UnrealInternalSignalEvents.RestAfkTimer]: void;
+    [UnrealInternalSignalEvents.FreezeFrameStart]: void;
+    [UnrealInternalSignalEvents.TelemetryReset]: void;
+    [UnrealInternalSignalEvents.TelemetryStart]: {
+        externalId: string;
+    };
+    [UnrealInternalSignalEvents.TelemetryStop]: {
+        externalId: string;
+        payload?: {
+            multi?: boolean;
+        };
+    };
+    [key: string]: any;
+}
+type UnrealCallBackJson = MetaBoxCommandPacket | WrappedMetaBoxCommandPacket;
+interface WrappedMetaBoxCommandPacket {
+    commandCallback: MetaBoxCommandPacket;
+}
+interface IAggregatedStat {
+    quality: Quality;
+    aggregatedStats: InboundVideoStats;
+}
+interface InboundVideoStats extends RTCInboundRtpStreamStats {
+    VideoEncoderQP: number;
+    runTime: number;
+    pixelRatio: number;
+    bytesReceivedStart: number;
+    framesDecodedStart: number;
+    timestampStart: number;
+    videoCodec: string;
+    avgBitrate: number;
+    avgFrameRate: number;
+    currentRoundTripTime: number;
+    codecs: Record<string, string>;
+    receiveToCompositeMs: number;
+    bitrate: number;
+    kalmanBitrate: number;
+    bitrateDrop: number;
+    dataFlowCheckResult: DataFlowCheckResult;
+    dataFlowBitrate: DataFlowCheckResult;
+}
+interface AwsInstance {
+    wsUrl: string | null;
+    pollingUrl: string | null;
+    instanceName: string | null;
+}
+
+declare class SignallingService extends SubService {
+    private readonly httpClient;
+    private readonly regionsPingService;
+    onConfig$: Subject<ConfigMessage>;
+    onWebRtcIce$: Subject<RTCIceCandidate>;
+    onWebRtcAnswer$: Subject<RTCSessionDescriptionInit | null>;
+    private ws;
+    protected wsTimeoutHandler: ReturnType<typeof setTimeout>;
+    private wsMsgHandlers;
+    protected correlationId: string;
+    protected environmentId: string;
+    private establishingConnection;
+    private isCirrusConnected;
+    private establishingConnectionDrop$;
+    constructor();
+    protected initEstablishingConnection(): void;
+    private stopEstablishingConnection;
+    private connectToSignaling;
+    private connectToSignalingAfterPing;
+    showStatusMessage(message: string | null): void;
+    /**
+     * Close the connection with the signaling server
+     * @param data
+     */
+    close(data: CloseReason | void): void;
+    send(data: string | object): void;
+    protected watchTimeoutOrErrorAndReconnectLater(): void;
+    protected stopRetryTimer(): void;
+    private initWebSocket;
+    private httpUrlToWs;
+    private clearWs;
+    protected handleMessage(msg: MessageBase): void;
+    private setHandlersFromStream;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignallingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignallingService>;
+}
+
+declare class VideoService extends SubService {
+    video: HTMLVideoElement | null;
+    audio: HTMLAudioElement | null;
+    container: HTMLDivElement | null;
+    create(): void;
+    private destroy;
+    private createWebRtcVideo;
+    attachVideoStream(stream: MediaStream): void;
+    attachAudioStream(stream: MediaStream): void;
+    private createWebRtcAudio;
+    private playAudio;
+    play(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VideoService>;
+}
+
+declare class VideoStreamStatusService extends SubService {
+    readonly latencyTestTimings: LatencyTimings;
+    private readonly webrtcPlayer;
+    private aggregatedStats;
+    private VideoEncoderQP;
+    private kalmanFilter1D;
+    readonly videoStats$: Observable<IAggregatedStat>;
+    constructor();
+    /**
+     * Aggregate video stats and emit it as videoStats$
+     */
+    private aggregateStats;
+    setEncoder(data: any): void;
+    private getStats;
+    private generateAggregatedStatsFunction;
+    private onAggregatedStats;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoStreamStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VideoStreamStatusService>;
+}
+
+declare class WebRtcPlayerService extends SubService {
+    pcClient: RTCPeerConnection | null;
+    onAudioTrack$: Subject<MediaStream>;
+    onVideoTrack$: Subject<MediaStream>;
+    onDataChannelMessage$: Subject<number[]>;
+    onWebRtcCandidate$: Subject<RTCIceCandidate>;
+    onWebRtcOffer$: Subject<RTCSessionDescriptionInit>;
+    private cfg;
+    private useMic;
+    private forceTURN;
+    private preferSFU;
+    private autoPlayAudio;
+    private startVideoMuted;
+    private forceMonoAudio;
+    private forceMaxBundle;
+    private dcClient;
+    private sdpConstraints;
+    private dataChannelOptions;
+    private webRtcErrorTimeout;
+    createWebRtcOffer(): Promise<void>;
+    createDataChannel(pc: RTCPeerConnection, label: string, options: RTCDataChannelInit): RTCDataChannel | null;
+    receiveAnswer(answer: RTCSessionDescriptionInit): void;
+    handleCandidateFromServer(iceCandidate: RTCIceCandidate): void;
+    mungeSDP(offer: RTCSessionDescriptionInit): void;
+    /**
+     * Closes existing PeerConnection
+     */
+    closePC(): void;
+    canSend(): boolean | null;
+    send(data: ArrayBuffer): void;
+    setConfig(parOptions?: ConfigMessage): void;
+    private dispatchWebRtcError;
+    private createOffer;
+    private setupTransceiversAsync;
+    private setupDataChannelCallbacks;
+    private onDataChannelConnected;
+    private handleCreateOffer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebRtcPlayerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebRtcPlayerService>;
+}
+
+declare class AggregatorService extends SubService {
+    #private;
+    readonly selectStreamConfig: i0.Signal<_3dsource_angular_unreal_module.StreamConfig | undefined>;
+    readonly videoService: VideoService;
+    readonly webrtcPlayer: WebRtcPlayerService;
+    readonly freezeFrame: FreezeFrameService;
+    readonly signallingSrv: SignallingService;
+    readonly stats: VideoStreamStatusService;
+    /**
+     * /Never called for now
+     * @
+     */
+    destroy$: Subject<void>;
+    responseEventListeners: Map<string, (data: unknown) => void>;
+    unlockViewport$: Observable<boolean>;
+    constructor();
+    init(): void;
+    private initialize;
+    /**
+     * @deprecated
+     * Hack for 3DS platform;
+     * TODO remove ASAP, use {@link BasicConfiguratorApiService.toMetaBoxHandlers.watchCallbacks}
+     * Add external responses to the list of responses
+     */
+    private addExternalResponses;
+    addResponseEventListener(name: string, listener: (data: unknown) => void): void;
+    showOnScreenKeyboard<T extends {
+        showOnScreenKeyboard: boolean;
+    }>(command: T): void;
+    exposeApi(): void;
+    removeLoadScreen(): void;
+    startListenCallbacks(): void;
+    private showMessageFromUnreal;
+    resetResponseList(): void;
+    listenSignaling(): void;
+    listenWebRTC(): void;
+    dataChannelMessageHandler(data: number[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AggregatorService>;
+}
+declare const filteredLogs: {
+    command: string;
+}[];
+
+declare class CommandTelemetryService {
+    private readonly appId;
+    private commandsSent;
+    private exileTimout;
+    private pollingTime;
+    private commandSequenceNumber;
+    /**
+     * The time the telemetry service was started.
+     * Initialized at a moment when connectToSignaling() was called.
+     * @private
+     */
+    private startTime;
+    private lastTime;
+    private uuid;
+    private viewId;
+    private readonly sessionId;
+    private readonly userId;
+    private payloads;
+    private readonly httpClient;
+    private readonly unrealInitialConfig;
+    constructor();
+    private get timeNow();
+    private get sessionTime();
+    private get canSkipSending();
+    decorate(funcToDecorate: IToBeDecorated): (data: any) => void;
+    private start;
+    private reset;
+    private trackStartCommand;
+    private trackStopCommand;
+    private pushStatToBuffer;
+    private trackTime;
+    private send;
+    /**
+     * Listens for Unreal Engine callbacks.
+     * Subscribes to the Unreal Engine event loop back and filters out events that do not have a tracking ID.
+     * When a callback with a tracking ID is received,
+     * it stops tracking the time for that command and filters out commands
+     * that have exceeded the timeout limit.
+     */
+    private listenCallbacks;
+    private pushData;
+    /**
+     * Removes commands that have exceeded the timeout limit.
+     * Iterates over all the commands sent and checks if the difference between the current time
+     * and the time the command was sent is greater than the timeout limit.
+     * If it is, the command is marked for deletion.
+     * After checking all commands, those marked for deletion are removed from the commands sent.
+     * This method is used to ensure that commands that are not responded to within a certain time frame
+     * do not remain in the commandsSent object indefinitely, which could lead to memory leaks over time.
+     */
+    private removeExileCommands;
+    /**
+     * Wraps the provided function with telemetry tracking.
+     * Generates a unique tracking ID and adds it to the data object.
+     * Pushes the command sent to the payloads with the tracking ID.
+     * Starts tracking the time for the command.
+     * Finally, calls the provided function with the modified data object.
+     *
+     * @param {IToBeDecorated} funcToDecorate - The function to be decorated with telemetry tracking.
+     * @param {any} data - The data object to be passed to the function. It will be augmented with a unique tracking ID.
+     */
+    private wrapper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandTelemetryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommandTelemetryService>;
+}
+type IToBeDecorated = (data: any) => unknown;
+declare function TelemetryStart(externalId: string): void;
+declare function TelemetryStop(externalId: string, payload?: any): void;
+declare function ResetTelemetry(): void;
+
+declare class ConsoleExtensionsService extends SubService {
+    private httpClient;
+    private isDevMode;
+    init(): void;
+    private unrealHelp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleExtensionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConsoleExtensionsService>;
+}
+
+declare class DevModeService {
+    get isDevMode(): boolean;
+    setDevMode(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevModeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevModeService>;
+}
+
+declare class InputService extends SubService {
+    private commandsSender;
+    private isDevMode;
+    readonly defaultKeys: (17 | 37 | 38 | 39 | 40 | 46 | 65 | 68 | 83 | 87 | 107 | 109 | 187 | 189)[];
+    private availableKeys;
+    private options;
+    private reInit$;
+    private deactivatedVideoTrigger$;
+    private normalizeAndQuantizeUnsigned;
+    private unQuantizeAndDenormalizeUnsigned;
+    private normalizeAndQuantizeSigned;
+    video: HTMLVideoElement;
+    videoBoundingRect: DOMRect;
+    fingerIds: Map<any, any>;
+    maxByteValue: number;
+    fingers: number[];
+    private offsetParams;
+    constructor();
+    useKeyboardKeys(keys: IKeyCode[]): void;
+    private setup;
+    /**
+     * We use `object-fit: cover` on the video element. Since the video can have
+     * a different aspect ratio from its container (and potentially be larger),
+     * we need to calculate offsets and scale factors to map container (e.g., mouse)
+     * coordinates back to the actual video coordinates.
+     *
+     * @param videoElement The video element whose scaling and positioning we need
+     * @returns Object containing offset and scale info for coordinate normalization
+     * @private
+     */
+    private getObjectFitOffset;
+    private setupNormalizeAndQuantize;
+    private sendInputData;
+    private registerInputs;
+    private getTouchPositionWithOffset;
+    private getMousePositionWithOffset;
+    private registerTouchEvents;
+    focusWindow(): void;
+    emitMouseMove(x: number, y: number, deltaX: number, deltaY: number): void;
+    emitMouseDown(button: number, x: number, y: number): void;
+    emitMouseUp(button: number, x: number, y: number): void;
+    emitMouseWheel(delta: number, x: number, y: number): void;
+    private releaseMouseButtons;
+    private pressMouseButtons;
+    private registerHoveringMouseEvents;
+    private registerMouseEnterAndLeaveEvents;
+    private isKeyCodeBrowserKey;
+    private getKeyCode;
+    private registerKeyboardEvents;
+    private startListenKeys;
+}
+
+declare class RegionsPingService {
+    private httpClient;
+    private unrealInitialConfig;
+    config: {
+        ping_count: number;
+        ping_timeout: number;
+        max_parallel_requests: number;
+        bust_cache: boolean;
+    };
+    constructor();
+    getFastest(regionListUrl?: string): Observable<string | undefined>;
+    getPingResult(providers: ProvidersData): Observable<PingResult | null>;
+    getProviders(regionList?: string): Observable<ProvidersData>;
+    private startPinging;
+    private checkLatency;
+    private fetchWithTimeout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionsPingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegionsPingService>;
+}
+interface ProvidersData {
+    timeout?: number;
+    regions: Region[];
+}
+interface Region {
+    region_code: string;
+    url: string;
+    timeout?: number;
+}
+interface PingResult {
+    region_code: string | undefined;
+    result: number[];
+}
+
+declare class StreamStatusTelemetryService {
+    #private;
+    constructor();
+    private mapEventData;
+    private initTelemetry;
+    private trackEventToMixPanel;
+    init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamStatusTelemetryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StreamStatusTelemetryService>;
+}
+
+declare class UnrealCommunicatorService {
+    private telemetry;
+    private afkService;
+    private freezeFrame;
+    private webrtcPlayer;
+    private videoService;
+    private consoleExtensions;
+    private store;
+    private destroy$;
+    private cirrusConnected;
+    constructor();
+    destroy(): void;
+    sendCommandToUnreal(data: MetaBoxCommandPacket): void;
+    emitUIInteraction(descriptor: MetaBoxCommandPacket): void;
+    /**
+     A build-in command can be sent to the UE4 client. The commands are defined by a
+     JSON descriptor and will be executed automatically.
+     The currently supported commands are:
+  
+     1. A command to run any console command:
+     "{ ConsoleCommand: <string> }"
+  
+     2. A command to change the resolution to the given width and height.
+     "{ Resolution.Width: <value>, Resolution.Height: <value> } }"
+     */
+    emitCommand(descriptor: MetaBoxCommandPacket): void;
+    sendInputData(data: ArrayBuffer): void;
+    private emitDescriptor;
+    private requestInitialSettings;
+    private requestQualityControl;
+    private listenVideo;
+    private prepareScreen;
+    private showPlayOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnrealCommunicatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnrealCommunicatorService>;
+}
+
+declare class AfkRestartScreenLockerComponent implements AfterViewInit, OnInit {
+    store: Store<any>;
+    videoService: VideoService;
+    destroyRef: DestroyRef;
+    showReconnectPopup: i0.Signal<boolean | undefined>;
+    isViewportReady: i0.Signal<boolean | undefined>;
+    imageLoadingSrc: i0.Signal<string | undefined>;
+    streamConfig: i0.Signal<_3dsource_angular_unreal_module.StreamConfig | undefined>;
+    isSecondStart: i0.WritableSignal<boolean>;
+    playCallBack: null | (() => void);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    connect(): void;
+    onDisconnect(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AfkRestartScreenLockerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AfkRestartScreenLockerComponent, "app-afk-restart-screen-locker", never, {}, {}, never, never, true, never>;
+}
+
+declare class StatGraphComponent implements AfterViewInit {
+    private el;
+    graph: ElementRef;
+    private canvas;
+    private ctx;
+    readonly color: i0.InputSignal<string>;
+    readonly tickStep: i0.InputSignal<number>;
+    readonly label: i0.InputSignal<string>;
+    private scaleY;
+    set dataTick(data: {
+        value: number;
+        hash: number;
+    } | null);
+    private data;
+    max: number;
+    min: number;
+    current: number;
+    ngAfterViewInit(): void;
+    resize(): void;
+    private draw;
+    private getColor;
+    private pushData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatGraphComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatGraphComponent, "app-stat-graph", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "tickStep": { "alias": "tickStep"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "dataTick": { "alias": "dataTick"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class UnrealSceneComponent implements AfterViewInit, OnInit, OnDestroy {
+    isStudio: i0.InputSignal<boolean>;
+    useContainerAsSizeProvider: i0.InputSignal<boolean>;
+    studioResolutionSize: i0.InputSignal<{
+        width: number;
+        height: number;
+    }>;
+    studioResolutionValues: rxjs.Observable<{
+        width: number;
+        height: number;
+    }>;
+    container: ElementRef;
+    changeMouseOverScene: i0.OutputEmitterRef<boolean>;
+    private width;
+    private height;
+    private store;
+    lightMode: i0.Signal<boolean | undefined>;
+    isFreezeFrameLoading: i0.Signal<boolean | undefined>;
+    private aggregatorService;
+    private commandsSender;
+    private inputService;
+    private videoService;
+    private stats;
+    private streamTelemetryService;
+    private element;
+    private destroyRef;
+    private get resizeValues();
+    private get pixelRatio();
+    onMouseOver(): void;
+    onMouseOut(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private adaptVideo;
+    /**
+     * This method calculates the dimensions for resizing a layout in a configurator stream.
+     * It takes into account the pixel ratio of the device's screen and the orientation of the layout.
+     * The method uses the `fitIntoRectangle` function to calculate the dimensions that would allow the layout to fit into the maximum space while maintaining its aspect ratio.
+     * It also sets the maximum limits for the width and height based on the layout's orientation.
+     * If the scale of the fitted dimensions is less than 1, it assigns the fitted dimensions to the output. Otherwise, it sets the scale of the output to 1.
+     * @returns {Area} An object of type `Area` that contains the calculated dimensions for resizing the layout.
+     */
+    private getResizeValuesUniversal;
+    private getResizeValues;
+    private sendResize;
+    private makeEven;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnrealSceneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UnrealSceneComponent, "app-unreal-scene", never, { "isStudio": { "alias": "isStudio"; "required": false; "isSignal": true; }; "useContainerAsSizeProvider": { "alias": "useContainerAsSizeProvider"; "required": false; "isSignal": true; }; "studioResolutionSize": { "alias": "studioResolutionSize"; "required": false; "isSignal": true; }; }, { "changeMouseOverScene": "changeMouseOverScene"; }, never, ["app-video-locker", "app-pdf", "app-show-case", "app-low-bandwidth-detector"], true, never>;
+}
+
+declare class VideoLockerComponent implements AfterViewInit, OnInit {
+    videoElement: ElementRef<HTMLDivElement>;
+    private store;
+    private destroyRef;
+    protected videoIntroSrc$: rxjs.Observable<string | null>;
+    protected imageIntroSrc$: rxjs.Observable<string | null>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private createVideo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoLockerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VideoLockerComponent, "app-video-locker", never, {}, {}, never, never, true, never>;
+}
+
+declare class VideoStatsComponent implements OnInit {
+    collapsed: boolean;
+    private store;
+    private videoStatGenerator;
+    private isDevMode;
+    private obs$;
+    viewportReady: i0.Signal<boolean | undefined>;
+    ssInfo: i0.Signal<string | undefined>;
+    fpsTick: i0.Signal<any>;
+    fpsAvgTick: i0.Signal<any>;
+    bitrateTick: i0.Signal<any>;
+    videoQP: i0.Signal<any>;
+    bitrateAverageTick: i0.Signal<any>;
+    videoStatus: i0.Signal<{
+        key: string;
+        value: any;
+    }[] | undefined>;
+    fields: string[];
+    graphList: any[];
+    graphList$: Observable<any>;
+    private idKey;
+    private elementsToShow;
+    private trigger$;
+    constructor();
+    ngOnInit(): void;
+    updateGraph(): void;
+    toggle(): void;
+    toggleGraph($event: MouseEvent, el: string, value?: any): void;
+    private getFields;
+    private writeFields;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoStatsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VideoStatsComponent, "app-video-stats", never, {}, {}, never, never, true, never>;
+}
+
+declare class WebrtcErrorModalComponent {
+    #private;
+    dialogRef: DialogRef<any, any>;
+    close(): void;
+    closeModalWithCirrusDisconnect(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebrtcErrorModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WebrtcErrorModalComponent, "app-webrtc-error-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterSettingsComponent implements OnInit {
+    private readonly storageKey;
+    readonly defaultFilterModel: {
+        minimumBitrate: number;
+        yellowFlag: number;
+        redFlag: number;
+        minimumFps: number;
+        monitoringDelayTime: number;
+        initialBitrateEstimate: number;
+        initialErrorCovariance: number;
+        processNoise: number;
+        measurementNoise: number;
+        panelOpen: boolean;
+    };
+    settings: {
+        minimumBitrate: number;
+        yellowFlag: number;
+        redFlag: number;
+        minimumFps: number;
+        monitoringDelayTime: number;
+        initialBitrateEstimate: number;
+        initialErrorCovariance: number;
+        processNoise: number;
+        measurementNoise: number;
+        panelOpen: boolean;
+    };
+    ngOnInit(): void;
+    togglePanel(): void;
+    saveSettings(): void;
+    dispatch(model: typeof DefaultFilterModel): void;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSettingsComponent, "app-filter-settings", never, {}, {}, never, never, true, never>;
+}
+
+declare class LowBandwidthDetectorComponent implements OnInit {
+    private readonly store;
+    private readonly dialog;
+    private readonly destroyRef;
+    private readonly videoStatGenerator;
+    readonly devModeService: DevModeService;
+    private readonly viewportReady$;
+    private readonly isLowBandwidth$;
+    private readonly lowBandwidthTrigger$;
+    private readonly highBandwidthTrigger$;
+    private readonly viewPortDestroyedTrigger$;
+    private readonly aggregatedStats$;
+    private readonly nativeQuality$;
+    private readonly monitoringTrigger$;
+    private readonly reTrigger$;
+    private readonly canSwitchToLowBand$;
+    private readonly videoQuality$;
+    private readonly fps$;
+    private readonly bitrateDrop$;
+    readonly fps: i0.Signal<number | undefined>;
+    readonly nativeQuality: i0.Signal<Quality | undefined>;
+    readonly isLowBandwidth: i0.Signal<boolean | undefined>;
+    readonly aggregatedStats: i0.Signal<_3dsource_angular_unreal_module.InboundVideoStats | undefined>;
+    readonly isReducedQuality: i0.WritableSignal<boolean>;
+    readonly isIndicatorExpanded: i0.WritableSignal<boolean>;
+    readonly isIndicatorExpandedTrigger$: rxjs.Observable<false>;
+    ngOnInit(): void;
+    private trySetLowBandwidth;
+    toggleIndicator(value: boolean): void;
+    hideIndicatorAfterDelay(): void;
+    openLBMDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LowBandwidthDetectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LowBandwidthDetectorComponent, "app-low-bandwidth-detector", never, {}, {}, never, never, true, never>;
+}
+
+declare class SafePipe implements PipeTransform {
+    private sanitizer;
+    transform(value: any, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", true>;
+}
+
+export { AFKService, AfkRestartScreenLockerComponent, AggregatorService, AnswerHandler, CONSOLE_COMMAND_DISABLE_MESSAGES, CONSOLE_COMMAND_ENABLE_MESSAGES, CONSOLE_COMMAND_PIXEL_QUALITY, ClickableOverlayComponent, CommandTelemetryService, ConfigHandler, ConsoleExtensionsService, DATA_CHANNEL_CONNECTION_TIMEOUT, DEBOUNCE_TO_MANY_RESIZE_CALLS, DEFAULT_TIMEOUT_PERIOD, DEFAULT_WARN_TIMEOUT, DataFlowMonitor, DevModeService, DisconnectReason, EControlSchemeType, EMessageType, EToClientMessageType, FULL_HD_HEIGHT, FULL_HD_WIDTH, FilterSettingsComponent, FreezeFrameComponent, FreezeFrameService, IceCandidateHandler, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, KalmanFilter1D, LatencyTimings, LowBandwidthDetectorComponent, LowBandwidthModalComponent, MINIMAL_FPS, MouseButton, MouseButtonsMask, OnCloseHandler, OnErrorHandler, OnMessageHandler, OnOpenHandler, OrchestrationMessageTypes, PingHandler, PlayerCountHandler, RegionsPingService, ResetTelemetry, SAME_SIZE_THRESHOLD, SCREEN_LOCKER_CONTAINER_ID, SSInfoHandler, STREAMING_VIDEO_ID, SafePipe, SignallingService, SpecialKeyCodes, StatGraphComponent, StreamStatusTelemetryService, SubService, TelemetryStart, TelemetryStop, UNREAL_CONFIG, UnrealCommunicatorService, UnrealEffects, UnrealInternalSignalEvents, UnrealSceneComponent, UnrealStatusMessage, VideoLockerComponent, VideoRecorder, VideoService, VideoStatsComponent, VideoStreamStatusService, WSCloseCode_NORMAL_AFK_TIMEOUT, WSCloseCode_NORMAL_CIRRUS_CLOSED, WSCloseCode_NORMAL_CLOSURE, WSCloseCode_NORMAL_MANUAL_DISCONNECT, WSCloseCodes, WS_OPEN_STATE, WS_TIMEOUT, WebRtcPlayerService, WebrtcErrorModalComponent, alignProductsToPlaneCommand, changeLowBandwidth, changeStatusMainVideoOnScene, changeStreamResolutionAction, changeStreamResolutionSuccessAction, clampAndKeepMaxPercents, clampPanToProductsCommand, commandCompleted, commandStarted, decodeData, destroyConnectionsAndResetState, destroyRemoteConnections, dispatchResize, filteredLogs, floatToSmoothPercents, forceResizeUnrealVideo, fromResizeObserver, fromSignal, fromUnrealCallBackSignal, getActiveUrl, getApplyCameraPresetCommand, getApplyZoomCommand, getCameraBoxCommand, getCameraRecenterCommand, getCameraSettingsCommand, getChangeGizmoTypeCommand, getChangeResolutionCommand, getClickSnapCommand, getControlSensitivityCommand, getDebugModeCommand, getDragCommand, getDragSequenceCommand, getDropCommand, getEnableComposureCommand, getEnableControlsCommand, getEnableSpinnerModeCommand, getEnableTeleportCommand, getExecuteConsoleCommand, getFitToObjectsCommand, getFreezeFrameCommand, getImageFromVideoStream, getInitSequenceByObjectNameCommand, getJumpToSequenceCommand, getLoadLevelCommand, getLoadProductCommand, getLoadSceneStateCommand, getLoopBackCommand, getMoveSelectedCommand, getPauseSequenceCommand, getPlaySequenceCommand, getRequestCameraPresetCommand, getResetControlClampsCommand, getRotateSelectedCommand, getRtcErrorMessage, getSelectProductByObjectNameCommand, getSetCameraControlClampsCommand, getSetControlCameraModeCommand, getSetFpsCommand, getSetMaterialCommand, getSetPawnMovementModeCommand, getSetSettingsSequenceCommand, getStopSequenceCommand, getTakeRenderCommand, getTakeSpinnerRenderCommand, getTakeSpinnerRenderPreviewCommand, getUnLoadAllProductsCommand, getUnLoadProductByObjectNameCommand, getUnselectAllProductsCommand, getWeatherCommand, initSignalling, initialState, mapQpToQuality, observeCommandResponse, removeExileCommands, resetAfk, resetAfkAction, resetConfig, resetIntroSrc, resetUnrealState, resetUnrealStateAction, resetWarnTimeout, selectCommandProgress, selectCommandsInProgress, selectFreezeFrameCombinedDataUrl, selectFreezeFrameDataUrl, selectFreezeFrameDataUrlFromVideo, selectFreezeFrameProgressMessageFromVideo, selectIsAutostart, selectIsFreezeFrameLoading, selectIsVideoPlayingAndDataChannelConnected, selectLastCommandInProgress, selectLoaderCommands, selectMatchUrls, selectShowLoader, selectShowReconnectPopup, selectSignalingParameters, selectStreamConfig, selectTotalProgress, selectWarnTimeout, selectWsUrl, sendSignal, setAwsInstance, setCirrusConnected, setCirrusDisconnected, setConfig, setDataChannelConnected, setErrorMessage, setEstablishingConnection, setFreezeFrame, setFreezeFrameFromVideo, setIntroImageSrc, setIntroVideoSrc, setLoadingImageSrc, setLoopBackCommandIsCompleted, setMatchUrls, setMaxFps, setProductsLocationCommand, setSignalingName, setStatusMessage, setStatusPercentSignallingServer, setStreamClientCompanyId, setStreamViewId, setViewportReady, showUnrealErrorMessage, trackMixpanelEvent, unLoadAllLevelsCommand, unrealFeature, unrealReducer, updateCirrusInfo };
+export type { AnswerMessage, AwsInstance, CandidateMessage, CloseReason, CommandsLoaderState, ConfigMessage, DataFlowCheckResult, DisconnectType, EControlSchemeTypeValues, EMessageTypeValues, FreezeFrameMessage, IAggregatedStat, InboundVideoStats, InputProps, InstanceReady, InstanceReserved, LBMStats, MessageBase, NormalizeAndQuantizeSignedValue, NormalizeAndQuantizeUnsignedValue, ObservedCallbackResponse, OrchestrationMessageType, PingMessage, PlayerCountMessage, PollingOrchestrationMessage, Quality, SSInfo, SignalDescriptor, SignalingData, SignalingMessageHandler, SignalingMessageMap, StreamConfig, StreamResolutionProps, TelemetryType, UnknownFields, UnquantizeAndDenormalizeUnsignedValue, UnrealCallBackJson, UnrealError, UnrealErrorType, UnrealInitialConfig, UnrealState, WSCloseCodesValues, WrappedMetaBoxCommandPacket };