@3dsource/angular-unreal-module/index.d.ts

Angular Unreal module for connect with unreal engine stream

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, FFreezeFrameV2Command, FUnfreezeFrameV2Command, FDragSequencePayload, FDragSequenceCommand, FAlignProductsToPlanePayload, FAlignProductsToPlaneCommand, FCameraPresetPayload, FApplyCameraPresetCommand, FLoadSceneStatePayload, FLoadSceneStateCommand, FClickSnapCommand, FControlCameraModePayload, FSetControlCameraModeCommand, FCameraClampsPayload, FSetCameraControlClampsCommand, FSetPawnMovementModePayload, FSetPawnMovementModeCommand, FEnableTeleportCommand, FEnableSceneStateCallbackCommand, 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 { IKeyCode, ImageOutputValues } 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 store;
    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 AggregatorService extends SubService {
    private readonly selectStreamConfig;
    private readonly videoService;
    private readonly webrtcPlayer;
    private readonly freezeFrame;
    private readonly unrealInitialConfig;
    private readonly responseEventListeners;
    /**
     * Never called for now
     */
    private readonly destroy$;
    constructor();
    init(): void;
    private initialize;
    private addResponseEventListener;
    private showOnScreenKeyboard;
    private removeLoadScreen;
    private startListenCallbacks;
    private showMessageFromUnreal;
    private resetResponseList;
    private listenWebRTC;
    private dataChannelMessageHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<AggregatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AggregatorService>;
}

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 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 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 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;
    dataChannelConnectionTimeout?: number;
}

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 = 8000;
declare const SIGNALLING_PERCENT_VALUE = 56;
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: RTCSessionDescriptionInit): 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 | Blob>): 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;
}
/**
 * Default LBM Filter Parameters
 */
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>);
/**
 * Creates an observable that emits values transitioning smoothly from the start value to the end value over a specified duration.
 * The transition is performed using linear interpolation (lerp) and clamped to the range [0, 1].
 *
 * @param {number} start - The starting value of the transition.
 * @param {number} end - The ending value of the transition.
 * @param {number} duration - The duration of the transition in milliseconds.
 * @returns {Observable<number>} An observable that emits the interpolated values from start to end over the specified duration.
 */
declare const smoothTransition: (start: number, end: number, duration: 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 getFreezeFrameNative: () => FFreezeFrameV2Command;
declare const getUnfreezeFrameNative: () => FUnfreezeFrameV2Command;
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 getEnableSceneStateCallbackCommand: (payload: FBoolPayload) => FEnableSceneStateCallbackCommand;
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 videoService;
    private dataChannelConnectionTimeout;
    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;
} | nu